gc 订阅
气相色谱(gas chromatography 简称GC)是二十世纪五十年代出现的一项重大科学技术成就。这是一种新的分离、分析技术,它在工业、农业、国防、建设、科学研究中都得到了广泛应用。气相色谱可分为气固色谱和气液色谱。 展开全文
气相色谱(gas chromatography 简称GC)是二十世纪五十年代出现的一项重大科学技术成就。这是一种新的分离、分析技术,它在工业、农业、国防、建设、科学研究中都得到了广泛应用。气相色谱可分为气固色谱和气液色谱。
信息
简    称
GC
类    别
科学技术成就
分    类
气固色谱和气液色谱
中文名
气相色谱
出现时间
二十世纪五十年代
外文名
gas chromatography
GC分类
气相色谱可分为气固色谱和气液色谱。气固色谱指流动相是气体,固定相是固体物质的色谱分离方法。例如活性炭、硅胶等作固定相。气液色谱指流动相是气体,固定相是液体的色谱分离方法。例如在惰性材料硅藻土涂上一层角鲨烷,可以分离、测定纯乙烯中的微量甲烷、乙炔、丙烯、丙烷等杂质。
收起全文
精华内容
参与话题
问答
  • Java Hotspot G1 GC的理解总结

    万次阅读 2020-05-12 17:52:29
    备注:后续学习后进行整体的总结 参考文献、书籍及链接 1.https://tech.meituan.com/2016/09/23/g1.html 2.书

    备注:后续学习后进行整体的总结

     

    参考文献、书籍及链接

    1.https://tech.meituan.com/2016/09/23/g1.html

    2.书

    展开全文
  • GC详解及Minor GC和Full GC触发条件总结

    万次阅读 多人点赞 2016-09-17 22:09:26
    GC,即就是Java垃圾回收机制。目前主流的JVM(HotSpot)采用的是分代收集算法。与C++不同的是,Java采用的是类似于树形结构的可达性分析法来判断对象是否还存在引用。即:从gcroot开始,把所有可以搜索得到的对象...

    GC,即就是Java垃圾回收机制。目前主流的JVM(HotSpot)采用的是分代收集算法。与C++不同的是,Java采用的是类似于树形结构的可达性分析法来判断对象是否还存在引用。即:从gcroot开始,把所有可以搜索得到的对象标记为存活对象。

    GC机制

    要准确理解Java的垃圾回收机制,就要从:“什么时候”,“对什么东西”,“做了什么”三个方面来具体分析。

    第一:“什么时候”即就是GC触发的条件。GC触发的条件有两种。(1)程序调用System.gc时可以触发(会建议JVM进行垃圾回收,不代表一定会进行GC);(2)系统自身来决定GC触发的时机。

    系统判断GC触发的依据:根据Eden区和From Space区的内存大小来决定。当内存大小不足时,则会启动GC线程并停止应用线程。

    第二:“对什么东西”笼统的认为是Java对象并没有错。但是准确来讲,GC操作的对象分为:通过可达性分析法无法搜索到的对象和可以搜索到的对象。对于搜索不到的方法进行标记。

    第三:“做了什么”最浅显的理解为释放对象。但是从GC的底层机制可以看出,对于可以搜索到的对象进行复制操作,对于搜索不到的对象,调用finalize()方法进行释放。

    具体过程:当GC线程启动时,会通过可达性分析法把Eden区和From Space区的存活对象复制到To Space区,然后把Eden Space和From Space区的对象释放掉。当GC轮训扫描To Space区一定次数后,把依然存活的对象复制到老年代,然后释放To Space区的对象。

    对于用可达性分析法搜索不到的对象,GC并不一定会回收该对象。要完全回收一个对象,至少需要经过两次标记的过程。

    第一次标记:对于一个没有其他引用的对象,筛选该对象是否有必要执行finalize()方法,如果没有执行必要,则意味可直接回收。(筛选依据:是否复写或执行过finalize()方法;因为finalize方法只能被执行一次)。

    第二次标记:如果被筛选判定位有必要执行,则会放入FQueue队列,并自动创建一个低优先级的finalize线程来执行释放操作。如果在一个对象释放前被其他对象引用,则该对象会被移除FQueue队列。

    GC过程中用到的回收算法:

    通过上面的GC过程不难看出,Java堆中的年轻代和老年代采用了不同的回收算法。年轻代采用了复制法;而老年代采用了标记-整理法

    具体各种回收算法的详解参考:http://www.cnblogs.com/dolphin0520/p/3783345.html

    JVM内存空间图解

     

    程序计数器:线程私有。是一块较小的内存,是当前线程所执行的字节码的行号指示器。是Java虚拟机规范中唯一没有规定OOM(OutOfMemoryError)的区域。

    Java栈:线程私有。生命周期和线程相同。是Java方法执行的内存模型。执行每个方法都会创建一个栈帧,用于存储局部变量和操作数(对象引用)。局部变量所需要的内存空间大小在编译期间完成分配。所以栈帧的大小不会改变。存在两种异常情况:若线程请求深度大于栈的深度,抛StackOverflowError。若栈在动态扩展时无法请求足够内存,抛OOM。

    Java堆:所有线程共享。虚拟机启动时创建。存放对象实力和数组。所占内存最大。分为新生代(Young区),老年代(Old区)。新生代分Eden区,Survivor区。Survivor区又分为From space区和To Space区。Eden区和Survivor区的内存比为8:1。 当扩展内存大于可用内存,抛OOM。

    方法区:所有线程共享。用于存储已被虚拟机加载的类信息、常量、静态变量等数据。又称为非堆(Non – Heap)。方法区又称“永久代”。GC很少在这个区域进行,但不代表不会回收。这个区域回收目标主要是针对常量池的回收和对类型的卸载。当内存申请大于实际可用内存,抛OOM。

    本地方法栈:线程私有。与Java栈类似,但是不是为Java方法(字节码)服务,而是为本地非Java方法服务。也会抛StackOverflowError和OOM。

     

     Minor GC ,Full GC 触发条件

    Minor GC触发条件:当Eden区满时,触发Minor GC。

    Full GC触发条件:

    (1)调用System.gc时,系统建议执行Full GC,但是不必然执行

    (2)老年代空间不足

    (3)方法去空间不足

    (4)通过Minor GC后进入老年代的平均大小大于老年代的可用内存

    (5)由Eden区、From Space区向To Space区复制时,对象大小大于To Space可用内存,则把该对象转存到老年代,且老年代的可用内存小于该对象大小

    注:本文为整理汇总,而非原创,所涉及的原文已找不到,如有发现还请告知 ^v^

    展开全文
  • JAVA GC垃圾回收机制详解

    万次阅读 2019-12-02 12:57:50
    既然提到了JVM那么我们必须得谈一谈GC垃圾回收机制了,在分析垃圾回收机制之前呢,我们还是需要来内存结构中堆(Heap)的详细结构。 图中展示了堆中三个区域:Eden、From Survivor、To Survivor。从图中可以也可以...

    引言

    在上一篇博客中我们详细分析了,JVM的内存结构。既然提到了JVM那么我们必须得谈一谈GC垃圾回收机制了,在分析垃圾回收机制之前呢,我们还是需要来内存结构中堆(Heap)的详细结构。image

     

    图中展示了堆中三个区域:Eden、From Survivor、To Survivor。从图中可以也可以看到它们的大小比例,准确来说是:8:1:1。为什么要这样设计呢,本篇文章后续会给出解答,还是根据垃圾回收的具体情况来设计的。

    还记得在设置JVM时,常用的类似-Xms和-Xmx等参数吗?对的它们就是用来说设置堆中各区域的大小的。

     image

    控制参数详解:

    • -Xms设置堆的最小空间大小。
    • -Xmx设置堆的最大空间大小。
    • -Xmn堆中新生代初始及最大大小(NewSize和MaxNewSize为其细化)。
    • -XX:NewSize设置新生代最小空间大小。
    • -XX:MaxNewSize设置新生代最大空间大小。
    • -XX:PermSize设置永久代最小空间大小。
    • -XX:MaxPermSize设置永久代最大空间大小。
    • -Xss设置每个线程的堆栈大小。

    对照上面两个图,再来看这些参数是不是没有之前那么枯燥了,它们在图中都有了对应的位置。

    有没有发现没有直接设置老年代空间大小的参数?我们通过简单的计算获得。

    1. 老年代空间大小=堆空间大小-年轻代大空间大小

    对上面参数立即了,但记忆有困难?那么,以下几个助记词可能更好的帮你记忆和理解参数的含义。

    Xmx(memory maximum), Xms(memory startup), Xmn(memory nursery/new), Xss(stack size)。

    对于参数的格式可以这样理解:

    • -: 标准VM选项,VM规范的选项。
    • -X: 非标准VM选项,不保证所有VM支持。
    • -XX: 高级选项,高级特性,但属于不稳定的选项

    GC概述

    垃圾收集(Garbage Collection)通常被称为“GC”,由虚拟机“自动化”完成垃圾回收工作。

    思考一个问题,既然GC会自动回收,开发人员为什么要学习GC和内存分配呢?为了能够配置上面的参数配置?参数配置又是为了什么?

    当需要排查各种内存溢出,内存泄露问题时,当垃圾成为系统达到更高并发量的瓶颈时,我们就需要对GC的自动回收实施必要的监控和调节。

    JVM中程序计数器、虚拟机栈、本地方法栈3个区域随线程而生随线程而灭。栈帧随着方法的进入和退出做入栈和出栈操作,实现了自动的内存清理。它们的内存分配和回收都具有确定性。

    因此,GC垃圾回收主要集中在堆和方法区,在程序运行期间,这部分内存的分配和使用都是动态的。

     GC回收流程

                                 

    (1)Eden区域是用来存放使用new或者newInstance等方式创建的对象,默认都是存放在Eden区,除非这个对象太大,或者超过了设定的阈值-XX:PretenureSizeThresold,这样的对象会被直接分配到Old区域。

    (2)2个Survivor(幸存)区,一般称S0,S1,理论上他们是一样大的,解释一下,他们是如何工作的:

    在不断创建对象的过程中,Eden区会满,这时候会开始做Young G也叫Minor GC,而Young空间的第一次GC就是找出Eden区中,幸存活着的对象,然后将这些对象,放到S0,或S1区中的其中一个, 假设第一次选择了S0,它会逐步将活着的对象拷贝到S0区域,但是如果S0区域满了,剩下活着的对象只能放old区域了,接下来要做的是,将Eden区域 清空,此时时候S1区域也是空的。

    当第二次Eden区域满的时候,就将Eden区域中活着的对象+S0区域中活着的对象,迁移到S1中,如果S1放不下,就会将剩下的部门,放到Old区域中,只是这次对象来源区域增加了S0,最后会将Eden区+S0区域,清空

    第三次和第四次依次类推,始终保证S0和S1有一个是空的,用来存储临时对象,用于交换空间的目的,反反复复多次没有被淘汰的对象,将会放入old区域中,默认是15次。具体的交换过程就和上图中的信息相似。

     

    如何判断对象存活

    判断对象常规有两种方法:引用计数算法和可达性分析算法(Reachability Analysis)。

    引用计数算法:给对象添加一个引用计数器,每当有一个地方引用它时计数器加1,引用释放时计数减1,当计数器为0时可以回收。

    引用计数算法实现简单,判断高效,在微软COM和Python语言等被广泛使用,但在主流的Java虚拟机中没有使用该方法,主要是因为无法解决对象相互循环引用的问题。

    可达性分析算法:基本思想是通过一系列称为“GC Root”的对象(如系统类加载器、栈中的对象、处于激活状态的线程等)作为起点,基于对象引用关系,开始向下搜索,所走过的路径称为引用链,当一个对象到GC Root没有任何引用链相连,证明对象是不可用的。

    image

    上图中中绿色部分为存活对象,灰色部分为可回收对象。虽然灰色部分内部依旧有关联,但它们到GC Root是不可达的。 

    面试问题

    面试官,说说Java GC都用了哪些算法?分别应用在什么地方?

    答:复制算法、标记清除、标记整理……

    标记清除算法

    标记清除(Mark-Sweep)算法,包含“标记”和“清除”两个阶段:首先标记出所有需要回收的对象,在标记完成后统一回收掉所有被标记的对象。

    标记清除算法是最基础的收集算法,后续的收集算法都是基于该思路并对其缺点进行改进而得到的。

                         image 

    主要缺点:一个是效率问题,标记和清除过程的效率都不高;另外是空间问题,标记清除之后会产生大量不连续的内存碎片,空间碎片太多可能会导致,当程序在以后的运行过程中需要分配较大对象时无法找到足够的连续内存而不得不提前触发另一次垃圾收集动作。

    复制算法

    复制(Copying)算法:将可用内存按容量划分为大小相等的两块,每次只使用其中的一块。当一块内存用完了,就将还存活着的对象复制到另外一块上,然后清理掉前一块。

    image

    每次对半区内存回收时、内存分配时就不用考虑内存碎片等复杂情况,只要移动堆顶指针,按顺序分配内存即可,实现简单,运行高效。

    缺点:将内存缩小为一半,性价比低,持续复制长生存期的对象则导致效率低下。

    JVM堆中新生代便采用复制算法。回到最初推分配结构图。

    image

     

    在GC回收过程中,当Eden区满时,还存活的对象会被复制到其中一个Survivor区;当回收时,会将Eden和使用的Survivor区还存活的对象,复制到另外一个Survivor区,然后对Eden和用过的Survivor区进行清理。

    如果另外一个Survivor区没有足够的内存存储时,则会进入老年代。

    这里针对哪些对象会进入老年代有这样的机制:对象每经历一次复制,年龄加1,达到晋升年龄阈值后,转移到老年代。

    在这整个过程中,由于Eden中的对象属于像浮萍一样“瞬生瞬灭”的对象,所以并不需要1:1的比例来分配内存,而是采用了8:1:1的比例来分配。

    而针对那些像“水熊虫”一样,历经多次清理依旧存活的对象,则会进入老年代,而老年的清理算法则采用下面要讲到的“标记整理算法”。

    标记整理算法

    标记整理(Mark-Compact)算法:标记过程与“标记-清除”算法一样,但后续步骤不是直接对可回收对象进行清理,而是让所有存活的对象都向一端移动,然后直接清理掉端边界以外的内存。

    image

    这种算法不既不用浪费50%的内存,也解决了复制算法在对象存活率较高时的效率低下问题。

    分代收集算法

    分代收集算法,基本思路:将Java的堆内存逻辑上分成两块,新生代和老年代,针对不同存活周期、不同大小的对象采取不同的垃圾回收策略。

    而在新生代中大多数对象都是瞬间对象,只有少量对象存活,复制较少对象即可完成清理,因此采用复制算法。而针对老年代中的对象,存活率较高,又没有额外的担保内存,因此采用标记整理算法。

    其实,回头看,分代收集算法就是对新生代和老年代算法从策略维度的规划而已。

    常见问题锦集

    1、对象进入Old区域有什么坏处?

    old区域一般称为老年代,老年代与新生代不一样,年轻代,我们可以认为存活下来的对象很少,而老年代则相反,存活下来的对象很多,所以JVM的 堆内存,才是我们通常关注的主战场,因为这里面活着的对象非常多,所以发生一次FULL GC,来找出来所有存活的对象是非常耗时的,因此,我们应该尽量避免FULL GC的发生。

    2、S0和S1一般多大,靠什么参数来控制,有什么变化?

    一般来说很小,我们大概知道它与Young差不多相差一倍的比例,设置的的参数主要有两个:

    -XX:SurvivorRatio=8

    -XX:InitialSurvivorRatio=8

    第一个参数是Eden和Survivor区域比重,注意是一个Survivor的的大小,如果将其设置为8,则说明Eden区是一个Survivor区的8倍,换句话说S0或S1空间是整个Young空间的1/10,剩余的80%由Eden区域来使用。

    第二个参数是Young/S0的比值,当其设置为8时,表示s0或s1占整个Young空间的12.5%。

    3、一个对象每次Minor Gc时,活着的对象都会在s0和s1区域转移,经过经过Minor GC多少次后,会进入Old区域呢?

    默认是15次,参数设置-XX:MaxTenuringThreshold=15,计数器会在对象的头部记录它交换的次数

    4、为什么发生FULL GC会带来很大的危害?

    在发生FULL GC的时候,意味着JVM会安全的暂停所有正在执行的线程(Stop The World),来回收内存空间,在这个时间段内,所有除了回收垃圾的线程外,其他有关JAVA的程序,代码都会静止,反映到系统上,就会出现系统响应大幅度变慢,卡机等状态。

    举个通俗易懂点的例子,就是在一个房间里,如果有一个人,不停的扔垃圾,然后有一个清洁工不停扫垃圾,这时候,我们的系统是OK的,因为基本不会 出现垃圾堆满房间的情景,而且因为清洁工可以对付过来,假设现在有10个人不停扔垃圾,那么就房间就会很快被堆满,这时候清洁工,由于工作不过来了,大声 吼一声,你们都暂停3分钟,别再扔了,我先把这个房间打扫完,你们才可以扔。

    在这个场景中,一个人扔,一个人扫,就类似于Minor GC,这时候,并不会影响扔垃圾的人,然后一旦10个人同时仍,而且很快就没地方仍了,这时候,就会触发Full GC,然后JVM下令,你们暂时都别仍了,等我什么时候回收完垃圾了,你们在仍,现在大家清楚了吧,所谓的10个人,就是类似我们成千上百的java类, 在不停的执行任务,所谓的清洁工,就是我们的GC机制,所以,大家在平时编码的时候,一定注意尽量少造点垃圾对象,这样触发FULL GC的几率,才会变小。

     

    展开全文
  • 深入理解GC ——MinorGC\MajorGC\FullGC

    万次阅读 多人点赞 2015-05-03 22:10:23
    发现网上很多关于GC的文章都自相矛盾,经过长期的积累验证,本文对很多含混的知识点做了严谨的解释,欢迎有理有据的拍砖! HotSpot虚拟机将其物理上划分为两个–新生代(young generation)和老年代(old ...

    发现网上很多关于GC的文章都自相矛盾,经过长期的积累验证,本文对很多含混的知识点做了严谨的解释,欢迎有理有据的拍砖!

    这里写图片描述

    HotSpot虚拟机将其物理上划分为两个–新生代(young generation)和老年代(old generation)、永久代(PermanentGeneration)

    • 涉及到的术语:

    • Stop-the-world
      意味着 JVM 因为要执行GC而停止了应用程序的执行。当Stop-the-world发生时,除了GC所需的线程以外,所有线程都处于等待状态,直到GC任务完成。GC优化很多时候就是指减少Stop-the-world发生的时间。
      MinGC\MajorGC都属于Stop-the-world, 那为什么MajorGC耗时较长呢?因为OldGen包含了大量存货下来的对象。

      Stop the World Event - All minor garbage collections are “Stop the
      World” events. This means that all application threads are stopped
      until the operation completes. Minor garbage collections are always
      Stop the World events.Major garbage collection are also Stop the World
      events. Often a major collection is much slower because it involves
      all live objects. So for Responsive applications, major garbage
      collections should be minimized. Also note, that the length of the
      Stop the World event for a major garbage collection is affected by the
      kind of garbage collector that is used for the old generation space.

    • gc进程,负责内存进行管理:

      • Step 1: Marking 标记出unreference object
        这里写图片描述
      • Step 2: Deletion and Compacting
        -1. 释放未被引用的对象
        -2 紧凑内存,是占用的内存在物理上连续,内存分配器持有空内存的地址头部。

    这里写图片描述

    新生代(Young generation)

    绝大多数最新被创建的对象会被分配到这里,由于大部分对象在创建后会很快变得不可到达,所以很多对象被创建在新生代,然后消失。对象从Young generation区域消失的过程我们称之为”minor GC
    Minor GC cleans the Young Generation.

    新生代构成

    新生代是用来保存那些第一次被创建的对象,他可以被分为三个空间

    1. Eden 空间 内存被调用的起点
    2. Survivor 0\Survivor 1 S0——>S1 ;age++

    这里写图片描述

    老年代(Old generation)

    对象没有变得不可达,并且从新生代中存活下来,会被拷贝到这里。其所占用的空间要比新生代多。也正由于其相对较大的空间,发生在老年代上的GC要比新生代少得多。对象从老年代中消失的过程,我们称之为**”major GC“ **

    这里写图片描述

    MinorGC Vs MajorGC

    When the new generation fills up, it triggers a minor collection in which the surviving objects are moved to the old generation. When the old generation fills up, it triggers a major collection which involves the entire object heap.

    看到这里,如果你可能有点晕, 记住
    MinGC

    1. As minor GCs continue to occure objects will continue to be promoted to the old generation space.
      2.When the eden space fills up, a minor garbage collection is triggered.

    minorGC 是清理整合YouGen的过程, eden 的清理,S0\S1的清理都由于MinorGC
    Allocation Failure(YoungGen区内存不足,不够调用) 会触发minorGC

    MajorGC:
    清理整合OldGen的内存空间

    Eventually, a major GC will be performed on the old generation which cleans up and compacts that space.

    MinorGC Vs FullGC

    Major GC 是清理OldGen。
    Full GC 是清理整个堆空间—包括年轻代和永久代。
    

    很不幸,实际上它还有点复杂且令人困惑。首先,许多 Major GC 是由 Minor GC 触发的,所以很多情况下将这两种 GC 分离是不太可能的。另一方面,许多现代垃圾收集机制会清理部分永久代空间,所以使用“cleaning”一词只是部分正确。

    这使得我们不用去关心到底是叫 Major GC 还是 Full GC,大家应该关注当前的 GC 是否停止了所有应用程序的线程,还是能够并发的处理而不用停掉应用程序的线程。

    另外,是什么触发fullGC呢?官网没有给出答案。从实际操作来看:
    FullGC触发场景:
    1、System.gc

    2.promotion failed (年代晋升失败,比如eden区的存活对象晋升到S区放不下,又尝试直接晋升到Old区又放不下,那么Promotion Failed,会触发FullGC)

    3.CMS的Concurrent-Mode-Failure 由于CMS回收过程中主要分为四步:
    1.CMS initial mark 2.CMS Concurrent mark 3.CMS remark 4.CMS Concurrent sweep。

    在2中gc线程与用户线程同时执行,那么用户线程依旧可能同时产生垃圾,
    如果这个垃圾较多无法放入预留的空间就会产生CMS-Mode-Failure,
    切换为SerialOld单线程做mark-sweep-compact。

    4.新生代晋升的平均大小 大于 老年代的剩余空间 (为了避免新生代晋升到老年代失败)

    当使用G1,CMS 时,FullGC发生的时候 是 Serial+SerialOld。
    当使用ParalOld时,FullGC发生的时候是 ParallNew +ParallOld.

    另外值得注意的是:日志里的 “Full”指非YGC的GC的STW次数! Full Gc 才是实际发生fullGC的次数。不要混淆。

    {Heap before GC invocations=3 (full 2):
     par new generation   total 30720K, used 27328K [0x00000000f9c00000, 0x00000000fbd50000, 0x00000000fbd50000)
      eden space 27328K, 100% used [0x00000000f9c00000, 0x00000000fb6b0000, 0x00000000fb6b0000)
      from space 3392K,   0% used [0x00000000fb6b0000, 0x00000000fb6b0000, 0x00000000fba00000)
      to   space 3392K,   0% used [0x00000000fba00000, 0x00000000fba00000, 0x00000000fbd50000)
     concurrent mark-sweep generation total 68288K, used 66909K [0x00000000fbd50000, 0x0000000100000000, 0x0000000100000000)
     Metaspace       used 9048K, capacity 9360K, committed 9600K, reserved 1058816K
      class space    used 1071K, capacity 1152K, committed 1152K, reserved 1048576K
    10.785: [GC (Allocation Failure) 10.785: [ParNew: 27328K->27328K(30720K), 0.0000174 secs]10.785: [CMS: 66909K->66417K(68288K), 0.1443041 secs] 94237K->86201K(99008K), [Metaspace: 9048K->9048K(1058816K)], 0.1443554 secs] [Times: user=0.16 sys=0.03, real=0.14 secs] 
    Heap after GC invocations=4 (full 3):
     par new generation   total 30720K, used 19783K [0x00000000f9c00000, 0x00000000fbd50000, 0x00000000fbd50000)
      eden space 27328K,  72% used [0x00000000f9c00000, 0x00000000faf51de0, 0x00000000fb6b0000)
      from space 3392K,   0% used [0x00000000fb6b0000, 0x00000000fb6b0000, 0x00000000fba00000)
      to   space 3392K,   0% used [0x00000000fba00000, 0x00000000fba00000, 0x00000000fbd50000)
     concurrent mark-sweep generation total 68288K, used 66417K [0x00000000fbd50000, 0x0000000100000000, 0x0000000100000000)
     Metaspace       used 9048K, capacity 9360K, committed 9600K, reserved 1058816K
      class space    used 1071K, capacity 1152K, committed 1152K, reserved 1048576K
    }
    
    {Heap before GC invocations=4 (full 4):
     par new generation   total 30720K, used 30719K [0x00000000f9c00000, 0x00000000fbd50000, 0x00000000fbd50000)
      eden space 27328K,  99% used [0x00000000f9c00000, 0x00000000fb6afff8, 0x00000000fb6b0000)
      from space 3392K, 100% used [0x00000000fb6b0000, 0x00000000fba00000, 0x00000000fba00000)
      to   space 3392K,   0% used [0x00000000fba00000, 0x00000000fba00000, 0x00000000fbd50000)
     concurrent mark-sweep generation total 68288K, used 68286K [0x00000000fbd50000, 0x0000000100000000, 0x0000000100000000)
     Metaspace       used 9055K, capacity 9360K, committed 9600K, reserved 1058816K
      class space    used 1071K, capacity 1152K, committed 1152K, reserved 1048576K
    11.088: [Full GC (Allocation Failure) 11.088: [CMS11.107: [CMS-concurrent-mark: 0.116/0.144 secs] [Times: user=0.39 sys=0.06, real=0.14 secs] 
     (concurrent mode failure): 68286K->68262K(68288K), 0.1883157 secs] 99006K->98318K(99008K), [Metaspace: 9055K->9055K(1058816K)], 0.1883465 secs] [Times: user=0.22 sys=0.00, real=0.19 secs] 
    Heap after GC invocations=5 (full 5):
     par new generation   total 30720K, used 30055K [0x00000000f9c00000, 0x00000000fbd50000, 0x00000000fbd50000)
      eden space 27328K, 100% used [0x00000000f9c00000, 0x00000000fb6b0000, 0x00000000fb6b0000)
      from space 3392K,  80% used [0x00000000fb6b0000, 0x00000000fb959fd0, 0x00000000fba00000)
      to   space 3392K,   0% used [0x00000000fba00000, 0x00000000fba00000, 0x00000000fbd50000)
     concurrent mark-sweep generation total 68288K, used 68262K [0x00000000fbd50000, 0x0000000100000000, 0x0000000100000000)
     Metaspace       used 9055K, capacity 9360K, committed 9600K, reserved 1058816K
      class space    used 1071K, capacity 1152K, committed 1152K, reserved 1048576K
    }
    

    持久代( permanent generation ):

    也被称为方法区(method area)。PerGen主要存放.class等文件 ,具体内容如下:

    • Methods of a class (including the bytecodes) 也就是类的方法。
    • Names of the classes (in the form of an object that points to a string also in the permanent generation) 类名称,当然也包括Interface\abstract class等等
    • Constant pool information (data read from the class file, see chapter 4 of the JVM specification for all the details).常量池
    • Object arrays and type arrays associated with a class (e.g., an object array containing references to methods).首先要知道数组存放的全部是引用,这里的意思应该是数组中的引用.
    • Internal objects created by the JVM (java/lang/Object or java/lang/exception for instance)
    • Information used for optimization by the compilers (JITs) JIT优化的相关信息

    运行时载入,另外,javaSE library classes and methods 也会在这里加载.
    permanent Gen 也会在FullGC时回收。

    Classes may get collected (unloaded) if the JVM finds they are no longer needed and space may be needed for other classes. The permanent generation is included in a full garbage collection.

    老年代GC处理机制

    老年代空间的GC事件基本上是在空间已满时发生,执行的过程根据GC类型不同而不同
    JDK7一共有5种GC类型:

    Serial GC
    Parallel GC
    Parallel Old GC (Parallel Compacting GC)
    Concurrent Mark & Sweep GC (or “CMS”)
    Garbage First (G1) GC

    jstat -gcutil PID

    被用于检查堆间的使用情况,GC执行的次数以及GC操作所花费的时间。
    建议使用gcviwer

    https://github.com/chewiebug/GCViewer

    如果GC执行满足了以下要求,GC并不需要优化:
    如需优化请参考:

    http://www.oracle.com/technetwork/java/javase/gc-tuning-6-140523.html

    Minor GC 执行快 (50 ms内).
    Minor GC 执行不频繁 (大概10s 执行一次).
    Full GC 执行快 (1 second内).
    Full GC 执行不频繁 (10 minutes 一次).

    参考原文地址:
    http://www.oracle.com/webfolder/technetwork/tutorials/obe/java/gc01/index.html
    http://www.oracle.com/webfolder/technetwork/tutorials/obe/java/gc01/index.html

    展开全文
  • Full GC (Metadata GC Threshold) jdk8JVM调优 MetaspaceSize元空间配置
  • jstat是用于监视虚拟机运行时状态信息的命令,它可以显示出虚拟机进程中的类装载、内存...[options] : 操作参数,一般使用 -gcutil 查看gc情况 VMID : 本地虚拟机进程ID,即当前运行的java进程号(PID) [interval] : ...
  • GC overhead limit exceeded 问题分析与解决

    万次阅读 多人点赞 2018-08-17 14:11:04
    今天出现了一个很奇怪的异常:java.lang.OutOfMemoryError: GC overhead limit exceeded ,超出了GC开销限制。科普了一下,这个是JDK6新添的错误类型。是发生在GC占用大量时间为释放很小空间的时候发生的,是一种...
  • 快速解读GC日志

    万次阅读 多人点赞 2015-10-18 21:00:27
    本文介绍GC日志的输出格式, 以及如何解读GC日志, 从中提取有用的信息。
  • Golang GC

    2018-12-15 11:40:01
    一、增量式 GC 二、 The GC runs concurrently with mutator threads, is type accurate (aka precise), allows multiple GC thread to run in parallel. It is a concurrent mark and sweep that uses a write ...
  • 对于JVM内存配置参数: -Xmx10240m -Xms10240m -Xmn5120m -XXSurvivorRatio=3 -Xms10240m 初始堆大小即最小内存值 XXSurvivorRatio=3,即Eden:FromSurvivor:ToSurvivor=3:1:1;所以Survivor一共是2048 ...
  • MinorGC和FullGC触发条件

    千次阅读 2018-11-22 14:03:39
    MinorGC 当Eden区满时,触发Minor GC。 FullGC 调用System.gc时,系统建议执行Full GC,但是不必然执行 老年代空间不足 方法区空间不足 通过Minor GC后进入老年代的平均大小大于老年代的可用内存 ...
  • GC 调试过程记录

    万次阅读 2020-07-31 20:20:56
    查看JVM配置 [root@localhost data]# java -version java version "1.8.0_231" # 版本 Java(TM) SE Runtime Environment (build 1.8.0_231-b11) Java HotSpot(TM) 64-Bit Server VM (build 25.231-b11, mixed ...
  • 7. GC 调优(实战篇) - GC参考手册

    万次阅读 多人点赞 2017-03-13 19:12:17
    JVM上运行的程序多种多样, 启动参数也有上百个, 其中有很多会影响到 GC, 所以调优GC性能的方法也有很多种。 还是那句话, 没有真正的银弹, 能满足所有的性能调优指标。 我们能做的只是介绍一些常见的/和不常见的示例...
  • 最近发现一个问题,应用在运行过程中Perm区占用不断增加,多次FullGC之后都没有下降。查看Dump文件之后,发现系统加载了很多类似sun.reflect.GeneratedSerializationConstructorAccessor这种名字的类。尝试设置sun....
  • 名词解释: GC:垃圾收集器 Minor GC:新生代GC,指发生在新生代的垃圾...Major GC/Full GC:老年代GC,指发生在老年代的GC。 JVM:Java Virtual Machine(Java虚拟机)的缩写。   正文: >堆 众所...
  • 1.GC回收机制熟悉么,分代算法知道么? 2.了解 Java 虚拟机的垃圾回收算法?  从年轻代空间(包括 Eden 和 Survivor 区域)回收内存被称为 Minor GC。 Major GC 是清理永久代。Full GC 是清理整个堆空间—包括年轻...
  • 深入理解Java-GC机制

    万次阅读 多人点赞 2018-04-13 15:28:14
    今天我们来谈谈Java主流虚拟机-HotSpot的GC实现机制,本篇文章默认使用HotSpot虚拟机进行介绍,如果没有特殊说明,其都为HotSpot虚拟机中的特性。 Java与C++之间有一堵由内存动态分配和垃圾收集技术所围城的“高墙...
  • 最近项目经常不正常的内存溢出,后面尝试打印了下GC日志 [CMS-concurrent-preclean: 0.348/0.351 secs] [Times: user=0.64 sys=0.02, real=0.35 secs] [CMS-concurrent-abortable-preclean: 0.054/0.054 secs] ...
  • GC收集器 •内存分配策略 •写在前面 JVM的垃圾回收算法、收集器以及内存分配策略放在一起了解和理解,我觉得有助于我们加深印象,这一篇文章我就不再讲述对象为什么要回收以及何时回收了,想要了解相关知识...
  • cadi gc 3.08 cadi gc 3.06
  • Minor GC、Major GC与Full GC

    千次阅读 2017-08-28 17:58:39
    Minor GC:从年轻代空间(包括 Eden 和 Survivor 区域)回收内存被称为 Minor GC。 Major GC:是清理老年代。 Full GC:是清理整个堆空间—包括年轻代和老年代。 年轻代是大多数新对象创建和销毁的地方,对象从...
  • GC日志可视化分析工具GCeasy和GCViewer

    千次阅读 2019-10-28 23:35:02
    上节介绍了GC日志的打印及含义,但是GC日志看起来比较麻烦,本节将会介绍一下GC日志可视化分析工具GCeasy和GCviewer。通过GC日志可视化分析工具,我们可以很方便的看到JVM各个分代的内存使用情况、垃圾回收次数、...
  • 名词解释: GC:垃圾收集器 Minor GC:新生代GC,指发生在新生代的垃圾收集动作,...Major GC/Full GC:老年代GC,指发生在老年代的GC。 JVM:Java Virtual Machine(Java虚拟机)的缩写。 正文: >堆 众所
  • 服务器一直报CPU饥饿,经过查看GC日志发现系统频繁出现full GC,求教各位大大,如何进行调优? 服务器配置: 8C48G jvm参数:-Xss1m -Xgcpolicy:optavgpause -Xmns256m -Xmnx512m -Xjit:codetotal=131072 -...
  • ART运行时Foreground GC和Background GC切换过程分析

    万次阅读 热门讨论 2015-05-04 00:57:34
    通过前面一系列文章的学习,我们知道了ART运行时既支持Mark-Sweep GC,又支持Compacting GC。其中,Mark-Sweep GC执行效率更高,但是存在内存碎片问题;而Compacting GC执行效率较低,但是不存在内存碎片问题。ART...
  • OutOfMemoryError系列(2): GC overhead limit exceeded

    万次阅读 多人点赞 2017-08-25 19:16:09
    Java运行时环境内置了 垃圾收集(GC) 模块. 上一代的很多编程语言中并没有自动内存回收机制, 需要程序员手工编写代码来进行内存分配和释放, 以重复利用堆内存。 在Java程序中, 只需要关心内存分配就行。如果某块内存...
  • 下面的gc log中的full gc是怎么触发的,理解不了,请大神看看~ ``` 2015-02-03T14:40:12.029+0800: 470.095: [GC [PSYoungGen: 1271672K->13218K(3940864K)] 1374109K->115656K(8135168K), 0.0061610 secs] ...
  • Minor GC、Major GC和Full GC之间的区别

    千次阅读 2016-06-07 20:48:32
    对Minor GC和Major GC做点笔记 新生代 GC(Minor GC):指发生在新生代的垃圾收集动作,因为 Java 对象大多都具 备朝生夕灭的特性,所以 Minor GC 非常频繁,一般回收速度也比较快。 老年代 GC(Major GC / ...
  • 4. GC 算法(实现篇) - GC参考手册

    万次阅读 多人点赞 2017-02-05 23:58:36
    学习了GC算法的相关概念之后, 我们将介绍在JVM中这些算法的具体实现。首先要记住的是, 大多数JVM都需要使用两种不同的GC算法 —— 一种用来清理年轻代, 另一种用来清理老年代。 我们可以选择JVM内置的各种算法。如果...
  • GC 日志分析

    2015-02-28 10:53:29
    性能测试排查定位问题,分析调优过程中,会遇到要分析gc日志,人肉分析gc日志有时比较困难,相关图形化或命令行工具可以有效地帮助辅助分析。Gc日志参数通过在tomcat启动脚本中添加相关参数生成gc日志-verbose.gc...

空空如也

1 2 3 4 5 ... 20
收藏数 68,503
精华内容 27,401
热门标签
关键字:

gc