精华内容
下载资源
问答
  • 系统和压缩内存磁盘占用的解决方案 最近一段时间玩游戏看视频经常莫名的卡顿,观察发现电脑卡的时候,WIN10进程中的“系统和压缩内存”一项占用了近100%的磁盘空间。 百度搜索到若干种解决方案,包括禁用家庭组...

    系统和压缩内存磁盘占用过高的解决方案

    最近一段时间玩游戏看视频经常莫名的卡顿,观察发现电脑卡的时候,WIN10进程中的“系统和压缩内存”一项占用了近100%的磁盘空间。

    百度搜索到若干种解决方案,包括禁用家庭组、禁用superfectch等等,尝试后均没有起到作用,在尝试了以下解决方案后,问题得到了解决,特此记录并与各位分享。


    1、右键此电脑并选择属性,然后点击“系统保护”,如图:

    764119-20160909184629098-974014547.png

    2、点击“高级-设置”,然后在性能选项中单击“虚拟内存”下的“更改”,如图

    764119-20160909184635691-940750297.png

    3、取消勾选“自动管理所有驱动器的分页文件大小”,选择除C盘外的磁盘,点击“自定义大小”,设置初始大小为2048,最大值为8192,保存后重启系统。

    764119-20160909184644894-1832662746.png

    系统和压缩内存占用磁盘的解决方法就讲到这里,电脑重启后,就不会出现磁盘被大量占用而卡机的情况了。

    转载于:https://www.cnblogs.com/Sunshine-tcf/p/5857744.html

    展开全文
  • 基于Zlib压缩率的测试,包含压缩比,压缩时间,cpu占用率,压缩耗时
  • 导语 |一般来说,在 App 的内存占用中,图片很容易成为其中的大头。特别是在图片相关的 App 中,稍不注意就容易引发内存占用的问题。本文将就 iOS 图片类应用的内存优化展开讨...

    导语 | 一般来说,在 App 的内存占用中,图片很容易成为其中的大头。特别是在图片相关的 App 中,稍不注意就容易引发内存占用过高的问题。本文将就 iOS 图片类应用的内存优化展开讨论,希望与大家一同交流。文章作者:张恒铭,腾讯终端开发工程师。

    一、内存优化的必要性

    事实上,因为目前 iPhone 配备的内存越来越高,当内存占用过高时,并不一定会超过系统设定的阈值而引发强杀进程。

    但这并不意味着减少内存占用是没有意义的,因为当内存占用过高时,很容易引起一系列的副作用。最直接的表现是 App Crash,当然还有很多更为深远的副作用。

    1. FOOM

    FOOM 是最直接的影响了,当内存占用过多导致整个系统的可用内存不足时,App所在的进程容易被杀掉。而且相比于一般的 Crash 来说,FOOM 更难以检测,并且也更难排查。

    2. 限制并发数量

    如果一个任务占用了过多的内存,但总的内存是有限的,那么任务的并发数将会受到直接限制。表现上就是 App 里某个功能可同时执行的数量有限,或者可以同时显示的内容有数量限制。

    同时,因为内存是有限资源,当占用内存过多时,会容易导致操作系统杀掉其它 App 的进程来给当前的 App 提供足够的内存空间,这对用户体验是不利的。

    3. 增加耗电

    由于 iOS 系统的 Memory Compressor 的存在,当可用内存不足时,一部分 Dirty Page 会被压缩存储到磁盘中,当用到这部分内存时,再从磁盘里加载回来。这会造成 CPU 花费更多的时间来等待 IO, 间接提高 CPU 占用率,造成耗电。


    二、原因分析

    1. 图片显示原理

    图片其实是由很多个像素点组成的,每个像素点描述了该点的颜色信息。这样的数据是可以被直接渲染在屏幕上的,称之为 Image Buffer。

    事实上,由于图片源文件占用的存储空间非常大,一般在存储时候都会进行压缩,非常常见的就是 JPEG 和 PNG 算法压缩的图片。

    因此当图片存储在硬盘中的时候,它是经过压缩后的数据。经过解码后的数据才能用于渲染,因此需要将图片显示在屏幕上的话,需要先经过解码。解码后的数据就是 Image Buffer 。

    当图片显示在屏幕上时,会复制显示区域的Image Buffer去进行渲染。


    2. 图片真实占用内存

    对于一张正在显示在屏幕上的,尺寸为 1920*1080 的图片来说,如果采用 SRGB 的格式(每个像素点的颜色由 red,green,blue,alpha 一个共 4 个 bytes 来决定)的话,那么它占用的内存为:

    1920 * 1080 * 4 = 829440 bytes
    
    
    

    也就是说,一张非常普通的图片,解码后占用的内存就是 7.9 MB,这是非常夸张的。而图片显示时所占的内存大小是与尺寸和颜色空间正相关的,与压缩算法、图片格式、图片文件的大小没有关联。


    三、解决方式


    1. 避免将图片放在内存里

    对于不显示在屏幕上的图片,在绝大部分时间里,其实是没有必要放在内存里的。解码后的 UIImage 是非常大的,对于不需要显示的图片是不需要解码的。而对于不显示在屏幕上的图片,一般也没有必要继续持有着 UIImage 对象。

    2. 图片缩放

    图片缩放是很常见的处理方式,一般来说,常见的思想可能是重新画一张小一点的图片,往往是用 UIGraphicsBeginImageContextWithOptions的方式:

    extension UIImage {        public func scaling(to size:CGSize) -> UIImage? {            let drawScale = self.scale            UIGraphicsBeginImageContextWithOptions(size, false, drawScale)            let drawRect:CGRect = CGRect(origin:.zero,size:size)            draw(in: drawRect)            let result = UIGraphicsGetImageFromCurrentImageContext()            UIGraphicsEndImageContext()            return result        }    }
    

    这种方式存在以下问题:


    第一,默认是 SRGB 的格式,也就是说每个像素需要占4个bytes的空间,对于一些黑白或者仅有alpha通道的数据来说是没有必要的。


    第二,需要将原图片完全解码后渲染出来,原图片的解码会造成内存占用的高峰。

    对于问题一的解决,可以使用新的 UIGraphicsImageRenderer 的方式,这种情况下框架会自动帮你选择对应的颜色格式,减少不必要的消耗。

    extension UIImage {    func scaling(to size:CGSize) -> UIImage? {        let renderer = UIGraphicsImageRenderer(bounds: CGRect(origin: .zero, size: size))        return renderer.image { context in            self.draw(in: context.format.bounds)        }    }}
    

    这种方式在一定的场景有所优化,但是没有解决问题二中存在的内存峰值的问题。由于处理前的图片并不一定展示在屏幕上,解码后的数据是冗余信息,因此应该避免图片的解码。

    对于峰值过高的问题,最直接的思想是采用流式的方式进行处理。而底层的 ImageIO  的接口就采用了这种方式:

    func resizedCgImage(url:URL,for size: CGSize) -> CGImage? {        let options: [CFString: Any] = [            kCGImageSourceShouldCache:false,            kCGImageSourceCreateThumbnailFromImageAlways: true,            kCGImageSourceCreateThumbnailWithTransform: true,            kCGImageSourceShouldCacheImmediately: true,            kCGImageSourceThumbnailMaxPixelSize: max(size.width, size.height)        ]                guard let imageSource = CGImageSourceCreateWithURL(url as NSURL, nil),            let image = CGImageSourceCreateThumbnailAtIndex(imageSource, 0, options as CFDictionary)            else {                                return nil        }                return image    }
    

    3. 降低峰值

    通过 ARC 管理内存的对象,注册在某个 Autoreleasepool 中,Autoreleasepool 在 drain 的时候释放已经没有使用的对象。

    一般没有进行特殊处理的话,会在 Runloop 结束后,有一次 Autoreleasepool 的 drain 操作,而这次 Runloop 中生成的对象也是由这个 Autoreleasepool 来管理的。这部分的原理有很多的文章介绍,这里就不多赘述了。

    在图片批量处理的过程中,由于还在一个 Runloop 里,此时引用计数为 0 的对象是不会被释放的。因此需要在每次循环后触发 Autoreleasepool 的 drain 操作:

    for image in images {    autoreleasepool {   operation()    }}
    

    4. 裁剪显示的图片

    在很多场景下,图片是不会完整的显示出来的,例如下图所示的情况:

    在这种情况中,即使给 UIImageView 一张完整的图片,最后渲染的时候也只会截取显示区域的 Image Buffer 去进行渲染。

    这就意味着,区域外的数据,其实是没有必要的。因此在这种场景下,其实只需要裁减显示区域的图片即可。

    举个例子,以前面提到 1920 * 1080 的图片为例, 显示时需要占用的内存为 829440 bytes。如果它是以 ScaleAspectFill 的方式放置在一个 300 x 300 的 UIImageView 中时,那么其实一张 300 x 300 的图片就足以展示,而此时这张图片占用的内存为 360000 bytes, 仅为前者的 43% 。

    
    
    func downsample(imageAt imageURL: URL, to pointSize: CGSize, scale: CGFloat) -> UIImage {        let imageSourceOptions = [kCGImageSourceShouldCache: false] as CFDictionary        let imageSource = CGImageSourceCreateWithURL(imageURL as CFURL, imageSourceOptions)!        let maxDimensionInPixels = max(pointSize.width, pointSize.height) * scale        let downsampleOptions =            [kCGImageSourceCreateThumbnailFromImageAlways: true,             kCGImageSourceShouldCacheImmediately: true,             kCGImageSourceCreateThumbnailWithTransform: true,             kCGImageSourceThumbnailMaxPixelSize: maxDimensionInPixels] as CFDictionary        let downsampledImage =            CGImageSourceCreateThumbnailAtIndex(imageSource, 0, downsampleOptions)!        return UIImage(cgImage: downsampledImage)    }
    


    四、效果对比

    在App进行优化前,是先将图片的原图显示出来,并且持有这些图片直到处理完毕。

    在处理方式上,采用了 UIGraphicsBeginImageContextWithOptions 的方式来进行图片的缩放。因此造成了持续的高内存占用,峰值可以达到 600 MB 。

    经过上述优化后,已经有了比较大的改观。同样的操作,总的内存占用为 221 MB,仅为之前的 36.4% 。


    参考资料:

    [1] iOS Memory Deep Dive:

    https://developer.apple.com/videos/play/wwdc2018/416

    [2] Image and Graphics Best Practices:

    https://developer.apple.com/videos/play/wwdc2018/219

    沙龙预告

    今晚20:00,腾讯云存储专家工程师王银虎做客云加社区沙龙直播间,深度解密腾讯云云硬盘CBS架构,扫描海报二维码或者点击文末「阅读原文」,即可预约观看今晚直播~


    展开全文
  • 它采用独特的软件算法,效率地将物理内存虚拟成物理硬盘,使得对硬盘文件的数据读写转化为对内存的数据访问。由于物理内存的访问速度远远超过传统硬盘,因此可以极大的提高数据读写速度,从而突破硬盘瓶颈,飞速...
  • C# 监测服务器使用情况(CPU、内存硬盘、网络宽带1、进程).zip
  • win10系统“系统和压缩内存占用大量资源导致电脑卡顿。可能是声音相关驱动导致,可能是虚存导致。

    电脑配置(i7-4710mq, 8g*2, ssd+机械硬盘),win10

    第一次出现问题

    很久以前用win10使用正常。后来加了8g内存组双通道(形成16g内存),发现电脑经常卡顿,于是以为是内存条问题(实际并不是),就拆了,问题解决。

    第二次出现问题

    暑假重装了win10,在家使用正常,回校后发现又出现卡顿问题。检查后发现在电脑卡顿的时候“系统和压缩内存”会占用25%-70%的CPU,磁盘使用会升至25%-50%。

    思考假期使用和在学校使用时的不同,发现在学校使用的耳机是AKG,在家用的是苹果耳机,百度后发现有人提出了“系统和压缩内存”占用大量资源可能是耳机口导致,发现重装时有一些声音的驱动没有装,装上后问题解决

    第三次出现问题

    于是认为和内存条没有关,重新把原来的内存条加上,过了一段时间又出现了卡顿问题。

    卡顿时发现cpu占用升高但不足50%,C盘占用100%。所以肯定不是CPU导致的卡机问题,但是磁盘C盘占用满应该不至于出现卡机。搜索后发现有人通过修改虚存的相关值解决了“系统和压缩内存”的问题[1]。于是推测因为虚存使用的盘正在被100%使用(因为有两块硬盘,C盘100%,总硬盘50%),所以虚存没法正常使用,导致卡机。

    于是通过设置:系统-系统保护-高级-设置-高级-更改-取消自动-无分页文件(如图),取消使用虚存,问题解决。

    后来发现我的C盘活动100%的原因是小红伞在后台自动扫描C盘文件,同理,其他地方所说的取消家庭组共享等方法都是为了减少硬盘活动。

    如果需要使用虚存,那就选择一个不会活动100%的磁盘。

    第四次出现问题

    用了几天后发现虽然磁盘没有被占用了但是“系统和压缩内存”会占用大量CPU导致卡机,搜索后发现“系统与压缩内存”是win10的新功能,以前当物理内存不足时电脑会使用虚存,但是即使ssd的速度也比内存慢很多,win10中会把不常用的数据压缩起来存在内存中,当需要时解压,所以占用cpu。现在发现休眠可以释放压缩的内存。通过设置电源选项可以选择合上盖子时休眠。休眠前备用有8g,可用才2g,并且任务管理器的内存使用只显示正在使用和被修改的比例,所以才使用了25%。休眠后备用被释放了,可用有11g,再也不卡顿了。
    [1]: http://www.cnblogs.com/Sunshine-tcf/p/5857744.html

    Sunshine-tcf的博客:系统和压缩内存磁盘占用过高的解决方案

    展开全文
  • 内存使用率88%高于80%报警。 原因: 指标含义:内存使用率百分比(%)。 指标解释:容器的内存使用率是读取物理机cgroup下面的文件的,获取的是整个容器的内存使用率并不是针对某个程序。物理机内存使用率和使用free...

    零、总结:

    本次问题通过分析,由于平时70%+的内存使用率,目前达到88%是由于5个月系统未重新发布内存数据和缓存不断增加以及堆内存的增加累计达到了内存使用率的报警阀值88%。
    在这里插入图片描述

    那么平时如果出现内存使用率偏高的问题,应该如何解决呢?下面的几个步骤其实就是从硬件-》系统-》进程来由大到小解决的。
    1、由于内存分配问题(也就是我这里的问题,对应解决办法如步骤1和2),


    2019-1-21 19:57:00 更新
    在深入理解java虚拟机(第二版)周志明的第5章中有高性能硬件上的程序部署策略,有一些指引方向,当时我排查问题还没看该书。特此在这里补充下。


    2、长期持有super big对象耗内存(对应解决办法如步骤3)
    3、死锁问题(对应解决办法如步骤4)
    4、其他原因比如poll长连接或者其他导致并发线程增多的原因(对应解决办法如步骤5和6)
    5、定位某个进程的内存什么问题(如步骤7)
    6、线程具体什么代码或者什么原因导致的(如步骤8)
    对于jvm8+调优点击下面
    参考实战和指导手册

    如果你是小白码农,还没有到达码工的层级,那么可以按照如下的教程定位问题。如果依然有疑问可以关注公众号【小诚信驿站】或者加 QQ群300458205

    一、知识点了解:

    了解下硬件和系统和进程之间的关系。
    在这里插入图片描述
    1.1硬件:
    top执行命令可以得到

    Cpu(s):  0.0%us,  0.3%sy,  0.0%ni, 99.7%id,  0.0%wa,  0.0%hi,  0.0%si,  0.0%st
    Mem:     73728k total,    70048k used,     3680k free,        0k buffers
    Swap:    16384k total,     4696k used,    11688k free,    64716k cached
    
    top看到的内存使用情况,有一部分是缓存,mem那行后面有个buffers ,swap那行后面有个cached,这两个就是缓存大小。所以如果要计算应用程序真正使用物理内存的情况,应该是used-cached-buffers才对,所以刚才top看到的物理内存使用情况为70048k-64716k=5332k。
    

    如果想要直接看内存使用情况可以执行 free命令 后面加个m是以M为单位显示

    free -m
    -----------
                  total       used       free     shared    buffers     cached
    Mem:            72         69          2          0          0         63
    -/+ buffers/cache:          5         66
    Swap:           16          4         11
    
    其中第一行用全局角度描述系统使用的内存状况: 
    total——总物理内存 
    used——已使用内存,一般情况这个值会比较大,因为这个值包括了cache+应用程序使用的内存 
    free——完全未被使用的内存 
    shared——应用程序共享内存 多个进程之间共享的内存部分,比如公共库libc.so等
    buffers——缓存,主要用于目录方面,inode值等(ls大目录可看到这个值增加)缓存将要放到硬盘里的数据 
    cached——缓存,缓存从硬盘读出来的数据用于已打开的文件:
    当你读写文件的时候,Linux内核为了提高读写性能与速度,会将文件在内存中进行缓存,这部分内存就是Cache Memory(缓存内存)。即使你的程序运行结束后,Cache Memory也不会自动释放。这就会导致你在Linux系统中程序频繁读写文件后,你会发现可用物理内存会很少。 
    其实这缓存内存(Cache Memory)在你需要使用内存的时候会自动释放,所以你不必担心没有内存可用。 
    只有当 free 减去 cached 剩下的这部分内存情况紧张时,才有可能出现应用程序没有足够内存使用的情况 
    注意-/+ buffers/cache: 5 66这行。 
    前个值表示-buffers/cache—–>不包括缓存,应用程序物理内存使用情况,即 -buffers/cache=used-buffers-cached ,所以此时应用程序才用了5M内存 。 
    后个值表示+buffers/cache—–>所有可供应用程序使用的内存大小,free加上缓存值,即+buffers/cache=free+buffers+cached ,所以此时还有接近66M 内存可供程序使用。 
    
    swap:
    交换分区、交互内存:
    
    交互分区属于硬盘空间,做为内存不足时的临时内存使用
    swap 主要的功能是当实体内存不够时,则某些在内存当中所占的程序会暂时被移动到 swap 当中,让实体内存可以被需要的程序来使用。另外,如果你的主机支持电源管理模式, 也就是说,你的 Linux 主机系统可以进入“休眠”模式的话,那么, 运行当中的程序状态则会被纪录到 swap 去,以作为“唤醒”主机的状态依据! 另外,有某些程序在运行时,本来就会利用 swap 的特性来存放一些数据段, 所以, swap 来是需要创建的!只是不需要太大!
    
    

    1.2系统:

    虚拟内存是操作系统内核为了对进程地址空间进行管理(process address space management)而精心设计的一个逻辑意义上的内存空间概念。我们程序中的指针其实都是这个虚拟内存空间中的地址。比如我们在写完一段C++程序之后都需要采用g++进行编译,这时候编译器采用的地址其实就是虚拟内存空间的地址。因为这时候程序还没有运行,何谈物理内存空间地址?凡是程序运行过程中可能需要用到的指令或者数据都必须在虚拟内存空间中。既然说虚拟内存是一个逻辑意义上(假象的)的内存空间,为了能够让程序在物理机器上运行,那么必须有一套机制可以让这些假象的虚拟内存空间映射到物理内存空间(实实在在的RAM内存条上的空间)。这其实就是操作系统中页映射表(page table)所做的事情了。内核会为系统中每一个进程维护一份相互独立的页映射表。页映射表的基本原理是将程序运行过程中需要访问的一段虚拟内存空间通过页映射表映射到一段物理内存空间上,这样CPU访问对应虚拟内存地址的时候就可以通过这种查找页映射表的机制访问物理内存上的某个对应的地址。“页(page)”是虚拟内存空间向物理内存空间映射的基本单元。
    

    1.3进程
    拿java举例
    在这里插入图片描述

    VSS- Virtual Set Size 虚拟耗用内存(包含共享库占用的内存)
    RSS- Resident Set Size 实际使用物理内存(包含共享库占用的内存)
    PSS- Proportional Set Size 实际使用的物理内存(比例分配共享库占用的内存)
    USS- Unique Set Size 进程独自占用的物理内存(不包含共享库占用的内存)
    一般来说内存占用大小有如下规律:VSS >= RSS >= PSS >= USS
    

    二、问题:

    内存使用率88%高于80%报警。

    三、原因:

    指标含义:内存使用率百分比(%)。
    指标解释:容器的内存使用率是读取物理机cgroup下面的文件的,获取的是整个容器的内存使用率并不是针对某个程序。物理机内存使用率和使用free命令计算结果是一致的。物理机和容器两者内存计算数据是独立的
    计算公式近似等于为:进程使用的(物理内存和本地内存和共享内存)、未被换出的物理内存大小,单位kb。RES=CODE+DATA

    四、解决步骤:

    用top中查看RES是操作系统角度看jvm的内存占用。
    用jmap查看的堆内存,是用jvm的角度看jvm内部程序的内存占用。
    存在差异是因为jvm有一些共享库和共享内存,被操作系统计入RES中,但未被jvm计入

    1、查看哪些应用占用内存比较大

    查看哪几个进程内存占用最高:top -c,输入大写M,以内存使用率从高到低排序
    

    在这里插入图片描述

    PID : 进程id
    PPID : 父进程id
    RUSER : Real user name
    UID : 进程所有者的用户id
    USER : 进程所有者的用户名
    GROUP : 进程所有者的组名
    TTY : 启动进程的终端名。不是从终端启动的进程则显示为 ?
    PR : 优先级
    NI : nice值。负值表示高优先级,正值表示低优先级
    P : 最后使用的CPU,仅在多CPU环境下有意义
    %CPU : 上次更新到现在的CPU时间占用百分比
    TIME : 进程使用的CPU时间总计,单位秒
    TIME+ : 进程使用的CPU时间总计,单位1/100秒
    %MEM : 进程使用的物理内存百分比
    VIRT : 进程使用的虚拟内存总量,单位kb。VIRT=SWAP+RES
    SWAP : 进程使用的虚拟内存中,被换出的大小,单位kb。
    RES : 进程使用的、未被换出的物理内存大小,单位kb。RES=CODE+DATA
    CODE : 可执行代码占用的物理内存大小,单位kb
    DATA : 可执行代码以外的部分(数据段+栈)占用的物理内存大小,单位kb
    SHR : 共享内存大小,单位kb
    nFLT : 页面错误次数
    nDRT : 最后一次写入到现在,被修改过的页面数。
    S : 进程状态。D=不可中断的睡眠状态 R=运行 S=睡眠 T=跟踪/停止 Z=僵尸进程
    COMMAND : 命令名/命令行
    WCHAN : 若该进程在睡眠,则显示睡眠中的系统函数名
    Flags : 任务标志,参考 sched.h
    
    默认情况下仅显示比较重要的 PID、USER、PR、NI、VIRT、RES、SHR、S、%CPU、%MEM、TIME+、COMMAND 列。可以通过下面的快捷键来更改显示内容。 更改显示内容
    通过 f 键可以选择显示的内容。按 f 键之后会显示列的列表,按 a-z 即可显示或隐藏对应的列,最后按回车键确定。
    按 o 键可以改变列的显示顺序。按小写的 a-z 可以将相应的列向右移动,而大写的 A-Z 可以将相应的列向左移动。最后按回车键确定。
    按大写的 F 或 O 键,然后按 a-z 可以将进程按照相应的列进行排序。而大写的 R 键可以将当前的排序倒转
    

    2、通过jmap -heap 进程id 命令排除是由于堆分配内存问题。得到如下结果

    Attaching to process ID 542287, please wait...
    Debugger attached successfully.
    Server compiler detected.
    JVM version is 25.20-b23
    
    using thread-local object allocation.
    Garbage-First (G1) GC with 43 thread(s)
    //堆配置信息
    Heap Configuration:
       //指定 jvm heap 在使用率小于 n 的情况下 ,heap 进行收缩 ,Xmx==Xms 的情况下无效 , 如 
       MinHeapFreeRatio         = 40
       //指定 jvm heap 在使用率大于 n 的情况下 ,heap 进行扩张 ,Xmx==Xms 的情况下无效 , 如 
       MaxHeapFreeRatio         = 70
       //最大堆空间
       MaxHeapSize              = 5393874944 (5144.0MB)
       //设置Yong Generation的初始值大小,一般情况下,不允许-XX:Newratio值小于1,即Old要比Yong大。
       NewSize                  = 1363144 (1.2999954223632812MB)
       //设置Yong Generation的最大值大小
       MaxNewSize               = 3235905536 (3086.0MB)
       OldSize                  = 5452592 (5.1999969482421875MB)
       //设置年轻代和老年代的比例,默认情况下,此选项为2
       NewRatio                 = 2
       //默认eden空间大小和survivor空间大小的比,默认情况下为8
       SurvivorRatio            = 8
       //初始化元空间大小,控制gc阀值,gc后动态增加或者降低元空间大小,默认情况下平台的不同,步长为12-20M
       MetaspaceSize            = 209715200 (200.0MB)
       //默认1G,这个参数主要是设置Klass Metaspace的大小,不过这个参数设置了也不一定起作用,前提是能开启压缩指针,假如-Xmx超过了32G,压缩指针是开启不来的。如果有Klass Metaspace,那这块内存是和Heap连着的。
       CompressedClassSpaceSize = 1073741824 (1024.0MB)
       //为类元数据分配的最大空间量
       MaxMetaspaceSize         = 536870912 (512.0MB)
       //堆内存中一个Region的大小可以通过-XX:G1HeapRegionSize参数指定,大小区间只能是1M、2M、4M、8M、16M和32M,总之是2的幂次方,如果G1HeapRegionSize为默认值,则在堆初始化时计算Region的实践大小
       G1HeapRegionSize         = 2097152 (2.0MB)
    //堆的使用信息
    Heap Usage:
    G1 Heap:
    //区域数量
       regions  = 2572
    //堆内存大小
       capacity = 5393874944 (5144.0MB)
    //已经使用了
       used     = 3216639400 (3067.62638092041MB)
    //空闲着的堆内存
       free     = 2177235544 (2076.37361907959MB)
       59.63503850933923% used
    以下同理
    G1 Young Generation:
    Eden Space:
       regions  = 425
       capacity = 2650800128 (2528.0MB)
       used     = 891289600 (850.0MB)
       free     = 1759510528 (1678.0MB)
       33.62341772151899% used
    Survivor Space:
       regions  = 1
       capacity = 2097152 (2.0MB)
       used     = 2097152 (2.0MB)
       free     = 0 (0.0MB)
       100.0% used
    G1 Old Generation:
       regions  = 1109
       capacity = 2740977664 (2614.0MB)
       used     = 2323252648 (2215.62638092041MB)
       free     = 417725016 (398.37361907958984MB)
       84.75999927009985% used
    
    35394 interned Strings occupying 3871104 bytes.
    

    截止到这里,本次问题已经找到了。因为设置的堆空间分配额比较大。将近63% =5g/8g。内存使用率计算公式为code+Data。本地内存和共享内存和可执行代码以外的部分(数据段+栈)等,当堆内存还没有达到full gc的时候,内存使用率问题就显现出来了。将内存分配最大值设为4g.并重新更新配置文件,发布应用
    在这里插入图片描述
    在这里插入图片描述
    但是这里存在一个问题,内存使用率高,刚才提到的一个情况就是堆内存接近最大值不会进行fullgc么?fullgc不就帮你回收堆空间了么?
    这是个好的问题。
    实际上他确实发生fullgc了,我们可以查到
    在这里插入图片描述
    在这里插入图片描述
    那么为什么没有解决内存使用率问题呢?而是将堆分配额重新调整之后,内存使用率才降下去。
    简单点说,就是如果你的项目需要人手10个人,你跟领导要了10个人,当项目只是第一个迭代干完了,那么你会不会立马将其中的5个人交给领导?答案是不会的,但是如果现在重新分配,领导说我就给你5个人下一个迭代你先干着,这样你就需要必须上交5个人。具体的点这里。详细的说明内存是如何管理的。


    如果上面也没有问题定位到原因,则继续按照步骤排查

    3、找到最耗内存的对象
    jmap -histo 进程ID(带上:live则表示先进行一次FGC再统计,如jmap -histo:live 进程ID)

    在这里插入图片描述
    可以看到上面最大的实例进程 将近30M。

    4、导出内存转储快照dump文件:
    4.1、通过java进程命令定位 系统进程并使用jmap工具dump文件。

    ps -ef | grep java 
    生成dump文件的命令:
    jmap -dump:format=b,file=20181218.dump 16048
    file后面的是自定义的文件名,最后的数字是进程的pid。
    

    4.2、使用jvisualvm来分析dump文件:

    jvisualvm是JDK自带的Java性能分析工具,在JDK的bin目录下,文件名就叫jvisualvm.exe。
    jvisualvm可以监控本地、远程的java进程,实时查看进程的cpu、堆、线程等参数,对java进程生成dump文件,并对dump文件进行分析。
    假设我现在下载下来的是txt文件也可以直接扔给jvisualvm来分析。
    

    在这里插入图片描述

    4.3、使用方式:直接双击打开jvisualvm.exe,点击文件->装入,在文件类型那一栏选择堆,选择要分析的dump文件,打开。

    导入文件以后界面如下图:
    在这里插入图片描述
    在这里插入图片描述

    可以看到,dump文件里记录的堆中的实例,总大小大概5392M左右,(用第一行的实例大小除以百分比就能算出来)

    4.4、现在看堆转储的线程问题

    在这里插入图片描述
    每一个部分的含义如下:
    “http-nio-1601-Acceptor-0” 线程名称
    daemon 线程的类型
    prio=5 线程的优先级别
    tid=290 线程ID
    RUNNABLE 线程当前的状态

    4.5、线程当前的状态是我们主要关注的内容。
    dump文件中描述的线程状态

    runnable:运行中状态,在虚拟机内部执行,可能已经获取到了锁,可以观察是否有locked字样。
    blocked:被阻塞并等待锁的释放。
    wating:处于等待状态,等待特定的操作被唤醒,一般停留在park(), wait(), sleep(),join() 等语句里。
    time_wating:有时限的等待另一个线程的特定操作。
    terminated:线程已经退出

    4.6、进程的区域划分

    进入区(Entry Set):等待获取对象锁,一旦对象锁释放,立即参与竞争。
    拥有区(The Owner):已经获取到锁。
    等待区(Wait Set):表示线程通过wait方法释放了对象锁,并在等待区等待被唤醒。

    4.7、方法调用修饰

    locked: 成功获取锁
    waiting to lock:还未获取到锁,在进入去等待;
    waiting on:获取到锁之后,又释放锁,在等待区等待;

    4.8、OQL(对象查询语言)
    如果需要根据某些条件来过滤或查询堆的对象,比如现在我们查询下系统中类加载器一共有几种?

    在这里插入图片描述

    4.9、引导计数
    引导类 (即 JVM 在未使用任何 java.lang.ClassLoader 实例的情况下加载的 Java 平台类) 的计数
    其余展示的与名称一样

    5、统计进程打开的句柄数:ls /proc/进程ID/fd |wc -l

    6、统计进程打开的线程数:ls /proc/进程ID/task |wc -l

    7、使用jstat查看进程的内存使用情况
    jstat [Options] vmid [interval] [count]
    Options,选项,我们一般使用 -gcutil 查看gc情况
    vmid,VM的进程号,即当前运行的java进程号
    interval,间隔时间,单位为秒或者毫秒
    count,打印次数,如果缺省则打印无数次

      S0     S1     E      O      M     CCS    YGC     YGCT    FGC    FGCT     GCT   
      0.00 100.00  32.20   7.05  48.98  95.35 102490 10125.674     1   39.100 10164.775
      0.00 100.00  32.57   7.05  48.98  95.35 102490 10125.674     1   39.100 10164.775
      0.00 100.00  32.94   7.05  48.98  95.35 102490 10125.674     1   39.100 10164.775
      0.00 100.00  33.31   7.05  48.98  95.35 102490 10125.674     1   39.100 10164.775
      0.00 100.00  33.62   7.05  48.98  95.35 102490 10125.674     1   39.100 10164.775
    
     S0C:年轻代中第一个survivor(幸存区)的容量 (字节) 
    S1C:年轻代中第二个survivor(幸存区)的容量 (字节) 
    S0U:年轻代中第一个survivor(幸存区)目前已使用空间 (字节) 
    S1U:年轻代中第二个survivor(幸存区)目前已使用空间 (字节) 
    EC:年轻代中Eden(伊甸园)的容量 (字节) 
    EU:年轻代中Eden(伊甸园)目前已使用空间 (字节) 
    OC:Old代的容量 (字节) 
    OU:Old代目前已使用空间 (字节) 
    PC:Perm(持久代)的容量 (字节) 
    PU:Perm(持久代)目前已使用空间 (字节) 
    YGC:从应用程序启动到采样时年轻代中gc次数 
    YGCT:从应用程序启动到采样时年轻代中gc所用时间(s) 
    FGC:从应用程序启动到采样时old代(全gc)gc次数 
    FGCT:从应用程序启动到采样时old代(全gc)gc所用时间(s) 
    GCT:从应用程序启动到采样时gc用的总时间(s) 
    NGCMN:年轻代(young)中初始化(最小)的大小 (字节) 
    NGCMX:年轻代(young)的最大容量 (字节) 
    NGC:年轻代(young)中当前的容量 (字节) 
    OGCMN:old代中初始化(最小)的大小 (字节) 
    OGCMX:old代的最大容量 (字节) 
    OGC:old代当前新生成的容量 (字节) 
    PGCMN:perm代中初始化(最小)的大小 (字节) 
    PGCMX:perm代的最大容量 (字节) 
    PGC:perm代当前新生成的容量 (字节) 
    S0:年轻代中第一个survivor(幸存区)已使用的占当前容量百分比 
    S1:年轻代中第二个survivor(幸存区)已使用的占当前容量百分比 
    E:年轻代中Eden(伊甸园)已使用的占当前容量百分比 
    O:old代已使用的占当前容量百分比 
    P:perm代已使用的占当前容量百分比 
    M:元空间中已使用的占当前容量百分比
    S0CMX:年轻代中第一个survivor(幸存区)的最大容量 (字节) 
    S1CMX :年轻代中第二个survivor(幸存区)的最大容量 (字节) 
    ECMX:年轻代中Eden(伊甸园)的最大容量 (字节) 
    DSS:当前需要survivor(幸存区)的容量 (字节)(Eden区已满) 
    TT: 持有次数限制 
    MTT : 最大持有次数限制
    
    

    8、.用jstack查看一下
    jstack pid | grep tid(线程ID) -A 30

    在这里插入图片描述

    展开全文
  • 入门学习Linux常用必会60个命令实例详解doc/txt

    千次下载 热门讨论 2011-06-09 00:08:45
    因为Linux与Windows不同,其后台运行着许多进程,所以强制关机可能会导致进程的数据丢失,使系统处于不稳定的状态,甚至在有的系统中会损坏硬件设备(硬盘)。在系统关机前使用 shutdown命令,系统管理员会通知所有...
  • MySQL 面试题

    万次阅读 多人点赞 2019-09-02 16:03:33
    因为 MySQL 还会有部分内容和运维相关度比较,所以本文我们分成两部分【开发】【运维】两部分。 对于【开发】部分,我们需要掌握。 对于【运维】部分,更多考验开发的知识储备情况,当然能回答出来是比较好的...
  • gzip解压和压缩,在内存使用

    热门讨论 2009-03-23 09:55:12
    里面有完整例子(BCB工程),很好了,我自己找了好久才找到呢
  • 降低Winform占用系统内存的方法-将物理内存占用挪到虚拟内存里 SetProcessWorkingSetSize(Process.GetCurrentProcess().Handle, -1, -1)
  • Linux 命令面试题

    万次阅读 多人点赞 2019-07-24 09:40:04
    hdparm -tT /dev/sda 在磁盘上执行测试性读取操作 cat /proc/cpuinfo 显示CPU info的信息 cat /proc/interrupts 显示中断 cat /proc/meminfo 校验内存使用 cat /proc/swaps 显示哪些swap被使用 cat /proc/...
  • 而如果把图像读取到内存中就不一样了,因为我们需要每一个像素都能在屏幕上显示,所以会把每个像素点都加载至内存中,不会对相同像素进行压缩或者是替换,所以你也应该能明白前面提到的Bitmap占用内存大小的计算公式...
  • Caffe简介

    千次阅读 多人点赞 2018-08-19 16:15:54
    caffe会根据网络需要正确占用内存,通过一个函数调用实现CPU和GPU之间的切换。 *测试覆盖 每一个单一的模块都对应一个测试 *python和matlab接口 同时提供两种接口 *预训练参考模型 针对视觉项目,...
  • VMware 虚拟机占用磁盘空间

    千次阅读 2017-09-30 10:22:10
    使用VMware创建的虚拟机尽管已经设定分配的磁盘大小,但仍然会发现虚拟机占用的磁盘空间会越来越大,而直观体现就是虚拟机系统文件 vmdk 不断增大。因此下面介绍一个简单的方法,使用 VMware 自带的工具对 vmdk 文件...
  • 解释:此处说的占据内存,是APP加载图片用的内存,即APP运行时图片占用内存,不考虑图片显示到界面占用内存(即只加载图片,不显示。因为显示图片时,系统有可能根据控件的大小或其他因素对内存进行了优化,不...
  • 第五章-Linux实操篇

    千次阅读 多人点赞 2019-10-24 18:45:20
    显示大型文件具有较的效率 。 操作 功能说明 空白键 向下移动一页 [pagedown] 向下翻动一页 [pageup] 向上翻动一页 /字串 向下搜寻[字串],n向下查询,N向上查询 ...
  • 史上最全面Java面试汇总(面试题+答案)

    万次阅读 多人点赞 2018-07-06 14:09:25
    面向对象和面向过程的区别 面向过程 优点:性能比面向对象,因为类调用时需要实例化,开销比较大,比较消耗资源;比如单片机、嵌入式开发、Linux/Unix等一般采用面向过程开发,性能是最重要的因素。 缺点:没有面向...
  • 史上最管用的C盘深度清理秘籍

    万次阅读 多人点赞 2019-03-09 15:37:43
    使用电脑的用户都知道,使用电脑一段时间后,会堆积很多无用的文件,不仅占用磁盘空间,而且导致系统运行速度变慢,所以清理c盘垃圾是非常有必要的。 无论我们给C盘分多大的分区,Windows都有办法把它填满。像休眠...
  • Tomcat面试题+http面试题+Nginx面试题+常见面试题

    千次阅读 多人点赞 2019-12-12 15:04:43
    worker工作模式占用内存较少,在并发下表现还算优异。不过必须要考虑线程安全的问题,因为多个子进程是共享父进程的内存地址的。如果使用keep-alive的长连接方式,也许中间几乎没有请求,这是就会发生阻塞,线程...
  • 图片内存溢出和图片压缩

    千次阅读 2012-03-09 00:12:48
    1) 要及时回收Bitmap的内存 Bitmap类有一个方法recycle(),从方法名可以看出意思是回收。这里就有疑问了,Android系统有自己的垃圾回收机制,可以不定期的回收掉不使用的内存空间,当然也包括Bitmap的空间。那为...
  • 使用内存硬盘(tmpfs)来加速网站

    千次阅读 2020-02-28 10:13:04
    准备工作 ...1、创建一个目录,比如/ramdisk,然后使用tmpfs命令挂载一部分内存当作硬盘 mount -t tmpfs -o size=256M tmpfs /ramdisk 此处我挂载了最大256M的内存到/tmp节点,值得注意的是系统不...
  • linux命令大全

    千次阅读 2015-12-24 08:44:14
    4. linux压缩备份命令 ... 67 ar 67 bunzip2 . 68 bzip2 . 68 bzip2recover 69 compress 69 cpio(copy in/out) 70 dump . 72 gunzip(gnu unzip) 73 gzexe(gzip executable) ...
  • 如何降低Windows程序的内存占用

    千次阅读 2012-12-08 16:18:17
    但是我发现软件再最小化之后物理内存占用量只有10M左右,于是感觉整个软件还有优化的空间,上网搜了一下搜到了一些解决办法,不过感觉下面这篇更专业,于是就转载了,以备不时之需。 在项目中对程序性能优化时,...
  • Nginx缓存的内存占用问题的一般解决方法 1、前些日子某服务被刷,每分钟达到上几百万请求;当时采用了nginx cache来解决的;但是因为某服务不能缓存太久,当时设置了5s,那么带来的问题就是产生大量小文件,而且很快...
  • Android性能优化之内存优化 计算 APP 获得的最大内存分配值 Runtime rt=Runtime.getRuntime(); long maxMemory=rt.maxMemory(); Log.i("maxMemory:",Long.toString...
  • 一、C# Winform应用程序占用内存较大解决方法整理(转) 原文:  http://www.jb51.net/article/56682.htm 背景: 微软的 .NET FRAMEWORK 现在可谓如火如荼了。但是,.NET 一直所为人诟病的就是“胃口太大”,狂...
  • Android中图片的存在形式: ...Bitmap的形式:图片占用内存会瞬间变大。 以下是代码的形式:   /** * 图片压缩的方法总结 */ /* * 图片压缩的方法01:质量压缩方法 */ private Bitmap compressImage(Bi
  • 一、C# Winform应用程序占用内存较大解决方法整理(转) 原文:http://www.jb51.net/article/56682.htm 背景: 微软的 .NET FRAMEWORK 现在可谓如火如荼了。但是,.NET 一直所为人诟病的就是“胃口太大”,狂吃...
  • 图片有两种使用的场景:一种是在硬盘上的存储格式,一个是在内存的展开格式。 一、在内存中的图片  因为需要知道图片的所有信息,所有在内存中,图片一般是展开的。那以带透明的Bitmap来说。这里有一些概念...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 42,412
精华内容 16,964
关键字:

压缩内存硬盘占用高