《深入理解JAVA虚拟机》第三章垃圾收集器与内存分配策略

蔚落 2022-03-20 17:24 184阅读 0赞

### 《深入理解java虚拟机 笔记》 ###

*  第三章 垃圾收集器与内存分配策略
 *   *  如何判断出对象已死?（对象已死是回收必要条件）
     *   *  引用计数算法
         *  可达性算法
         *  引用分强、软、弱、虚引用
         *  可达性分析算法中不可达的对象并非“非死不可”
     *  回收方法区
     *  垃圾收集算法
     *   *  标记-清除算法
         *  复制算法
         *  标记-整理算法
         *  实际使用的分代收集算法
     *  HotSpot算法实现
     *  HotSpot中的垃圾收集器
     *   *  Serial收集器(了解)
         *  Serial Old收集器(了解)
         *  ParNew收集器(了解)
         *  Parallel Scavenge收集器(了解)
         *  Parallel Old收集器(了解)
         *  CMS收集器
         *  G1收集器
     *  GC日志含义
     *  虚拟机实现内存分配的几条原则
     *   *  对象优先在Eden分配
         *  大对象直接进入老年代
         *  长期存活的对象将进入老年代
         *  动态对象年龄判定
         *  空间分配担保
     *  本章小结

# 第三章 垃圾收集器与内存分配策略 #

此章主要围绕三个问题，java虚拟机中**哪些内存需要回收？什么时候回收？如何回收**？第二章中介绍了虚拟机内存中程序计数器、虚拟机栈、本地方法栈三个数据区随着线程结束而消亡，所以这三个区域不用考虑回收问题。**因此需要注意的，垃圾回收是在java堆和方法区中回收，另外三个区域不用**。

## 如何判断出对象已死?（对象已死是回收必要条件） ##

### 引用计数算法 ###

作者说，很多应届生都是这么回答的，给对象中添加一个引用计数器，每当有一个地方引用它时，计数器值就加1；当引用失效时，计数器值就减1；任何时刻计数器为0的对象就是不可能再被使用的。但是他自己并没有给出定义。**在主流的java虚拟机中没有选用引用计数算法来管理内存，其中最主要的原因是它很难解决对象之间相互循环引用的问题**。  
  要查看GC日志，需要设置一下jvm的参数。

> \-XX:+PrintGC 输出GC日志  
> \-XX:+PrintGCDetails 输出GC的详细日志  
> \-XX:+PrintGCTimeStamps 输出GC的时间戳（以基准时间的形式）  
> \-XX:+PrintGCDateStamps 输出GC的时间戳（以日期的形式，如 2013-05-04T21:53:59.234+0800）  
> \-XX:+PrintHeapAtGC 在进行GC的前后打印出堆的信息  
> \-Xloggc:…/logs/gc.log 日志文件的输出路径

ReferenceCountingGC例子中， objA.instance = objB; objB.instance = objA;两个对象相互引用，其引用计数都不为0，但是GC收集器还是回收他们，说明虚拟机并不是使用引用计数算法判断对象是否存活的。

public class ReferenceCountingGC{ 
    	public Object instance = null;
    	private static final int _1MB = 1024*1024;
    /** *这个成员属性的唯一意义就是占点内存，以便能在GC日志中看清楚是否被回收过 */
    	private byte[]bigSize = new byte[2*_1MB];
    	public static void testGC(){ 
    		ReferenceCountingGC objA = new ReferenceCountingGC();
    		ReferenceCountingGC objB = new ReferenceCountingGC();
    		objA.instance = objB;
    		objB.instance = objA;
    		objA = null;
    		objB = null;
    		//假设在这行发生GC,objA和objB是否能被回收？
    		System.gc();
    	}
    	public static void main(String[] args) { 
    		ReferenceCountingGC referenceCountingGC = new ReferenceCountingGC();
    		referenceCountingGC.testGC();
    	}
    }

运行结果：

[GC (System.gc()) [PSYoungGen: 7455K->2536K(18944K)] 7455K->2688K(62976K), 0.0027933 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
    [Full GC (System.gc()) [PSYoungGen: 2536K->0K(18944K)] [ParOldGen: 152K->2594K(44032K)] 2688K->2594K(62976K), [Metaspace: 2727K->2727K(1056768K)], 0.0246085 secs] [Times: user=0.05 sys=0.00, real=0.02 secs] 
    Heap
     PSYoungGen      total 18944K, used 164K [0x00000000eb300000, 0x00000000ec800000, 0x0000000100000000)
      eden space 16384K, 1% used [0x00000000eb300000,0x00000000eb3290d0,0x00000000ec300000)
      from space 2560K, 0% used [0x00000000ec300000,0x00000000ec300000,0x00000000ec580000)
      to   space 2560K, 0% used [0x00000000ec580000,0x00000000ec580000,0x00000000ec800000)
     ParOldGen       total 44032K, used 2594K [0x00000000c1800000, 0x00000000c4300000, 0x00000000eb300000)
      object space 44032K, 5% used [0x00000000c1800000,0x00000000c1a88918,0x00000000c4300000)
     Metaspace       used 2734K, capacity 4486K, committed 4864K, reserved 1056768K
      class space    used 304K, capacity 386K, committed 512K, reserved 1048576K

由于调用了System.gc()方法，所以触发了 \[Full GC (System.gc())，PSYoungGen为Parallel Scavenge收集器新生代，ParOldGen为Parallel Scavenge收集器老年代。2688K->2594K(62976K)表示回收前该内存区域使用容量2688K，回收后该内存使用容量2594K，虚拟机并没有因为这两个对象相互引用就没有回收它们。

### 可达性算法 ###

在主流的商用程序语言（Java、C\#，甚至包括前面提到的古老的Lisp）的主流实现中，都是称通过可达性分析（Reachability Analysis）来判定对象是否存活的。**这个算法的基本思路就是通过一系列的称为“GC Roots”的对象作为起始点，从这些节点开始向下搜索，搜索所走过的路径称为引用链（Reference Chain），当一个对象到GC Roots没有任何引用链相连（用图论的话来说，就是从GC Roots到这个对象不可达）时，则证明此对象是不可用的**。如图3-1所示，对象object 5、object 6、object 7虽然互相有关联，但是它们到GC Roots是不可达的，所以它们将会被判定为是可回收的对象。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTI2MjQ1Mw_size_16_color_FFFFFF_t_70]  
在Java语言中，可作为GC Roots的对象包括下面几种：

*  虚拟机栈（栈帧中的本地变量表）中引用的对象。
 *  方法区中类静态属性引用的对象。
 *  方法区中常量引用的对象。
 *  本地方法栈中JNI（即一般说的Native方法）引用的对象。

### 引用分强、软、弱、虚引用 ###

无论是通过引用计数算法判断对象的引用数量，还是通过可达性分析算法判断对象的引用链是否可达，判定对象是否存活都与“引用”有关。在JDK 1.2以前，Java中的引用的定义很传统：如果reference类型的数据中存储的数值代表的是另外一块内存的起始地址，就称这块内存代表着一个引用。这种定义很纯粹，但是太过狭隘，一个对象在这种定义下只有被引用或者没有被引用两种状态，对于如何描述一些“食之无味，弃之可惜”的对象就显得无能为力。我们希望能描述这样一类对象：当内存空间还足够时，则能保留在内存之中；如果内存空间在进行垃圾收集后还是非常紧张，则可以抛弃这些对象。很多系统的缓存功能都符合这样的应用场景。  
  在JDK 1.2之后，Java对引用的概念进行了扩充，将引用分为强引用（Strong  
Reference）、软引用（Soft Reference）、弱引用（Weak Reference）、虚引用（PhantomReference）4种，这4种引用强度依次逐渐减弱。  
  **强引用描述垃圾收集器永远不会回收对象**，就是指在程序代码之中普遍存在的，类似“Object obj=new Object（）”这类的引用，只要强引用还存在，垃圾收集器永远不会回收掉被引用的对象。  
  **软引用是用来描述一些还有用但并非必需的对象**。对于软引用关联着的对象，在系统将要发生内存溢出异常之前，将会把这些对象列进回收范围之中进行第二次回收。如果这次回收还没有足够的内存，才会抛出内存溢出异常。在JDK 1.2之后，提供了SoftReference类来实现软引用。  
  **弱引用也是用来描述非必需对象的，但是它的强度比软引用更弱一些，被弱引用关联的对象只能生存到下一次垃圾收集发生之前**。当垃圾收集器工作时，无论当前内存是否足够，都会回收掉只被弱引用关联的对象。在JDK 1.2之后，提供了WeakReference类来实现弱引用。  
  **虚引用也称为幽灵引用或者幻影引用，它是最弱的一种引用关系。一个对象是否有虚引用的存在，完全不会对其生存时间构成影响，也无法通过虚引用来取得一个对象实例**。为一个对象设置虚引用关联的唯一目的就是能在这个对象被收集器回收时收到一个系统通知。在JDK 1.2之后，提供了PhantomReference类来实现虚引用。

### 可达性分析算法中不可达的对象并非“非死不可” ###

在可达性分析算法中不可达的对象，也并非是“非死不可”的，这时候它们暂时处于“缓刑”阶段，要真正宣告一个对象死亡，至少要经历两次标记过程。  
第一次标记：如果对象在进行可达性分析后发现没有与GC Roots相连接的引用链，那它将会被第一次标记。  
第二次标记：第二次标记发生在“即将回收”的集合中，进一步标记确认要回收的对象，当然如果对象执行方法finalize()成功拯救了自己就不会标记。  
  如果对象有覆盖finalize()方法并且系统之前没有调用过对象的finalize()方法方法，那么这个对象会放在一个F-Queue的队列之中，并在稍后由一个由虚拟机自动建立的、低优先级的Finalizer线程去执行它。对象在执行方法finalize()中要想成功拯救自己——只要重新与引用链上的任何一个对象建立关联即可，譬如把自己（this关键字）赋值给某个类变量或者对象的成员变量，那在第二次标记时它将被移除出“即将回收”的集合。  
  如果对象的finalize()方法有被系统调用过，那将不会再执行finalize()方法，第二次标记时会直接标记确认回收。  
从代码清单3-2中我们可以看到一个对象的finalize()被执行，但是它仍然可以存活。

/** *此代码演示了两点： *1.对象可以在被GC时自我拯救。 *2.这种自救的机会只有一次，因为一个对象的finalize()方法最多只会被系统自动调用一次 *@author zzm */
    public class FinalizeEscapeGC{ 
    	public static FinalizeEscapeGC SAVE_HOOK = null;
    	public void isAlive(){ 
    		System.out.println("yes,i am still alive：)");
    	}
    	@Override
    	protected void finalize()throws Throwable{ 
    		super.finalize();
    		System.out.println("finalize mehtod executed！");
    		FinalizeEscapeGC.SAVE_HOOK = this;
    	}
    	public static void main(String[]args)throws Throwable{ 
    		SAVE_HOOK = new FinalizeEscapeGC();
    		//对象第一次成功拯救自己
    		SAVE_HOOK = null;
    		System.gc();
    		//因为finalize方法优先级很低，所以暂停0.5秒以等待它
    		Thread.sleep(500);
    		if(SAVE_HOOK != null){ 
    			SAVE_HOOK.isAlive();
    		}else{ 
    			System.out.println("no,i am dead：(");
    		}
    		//下面这段代码与上面的完全相同，但是这次自救却失败了
    		SAVE_HOOK = null;
    		System.gc();
    		//因为finalize方法优先级很低，所以暂停0.5秒以等待它
    		Thread.sleep(500);
    		if(SAVE_HOOK  != null){ 
    			SAVE_HOOK.isAlive();
    		}else{ 
    			System.out.println("no,i am dead：(");
    		}
    	}
    }

运行结果：  
代码中有两段完全一样的代码片段，执行结果却是一次逃脱成功，一次失败，这是因为任何一个对象的finalize()方法都只会被系统自动调用一次，如果对象面临下一次回收，它的finalize()方法不会被再次执行，因此第二段代码的自救行动失败了。  
![在这里插入图片描述][20190214103547488.png]

## 回收方法区 ##

**堆被划分成两个不同的区域：新生代 ( Young )、老年代 ( Old )**。新生代 ( Young ) 又被划分为三个区域：Eden、From Survivor、To Survivor。  
**JVM的方法区，也被称为永久代**。在这里都是放着一些被虚拟机加载的类信息，静态变量，常量等数据。这个区中的东西比老年代和新生代更不容易回收。  
  很多人认为方法区（或者HotSpot虚拟机中的永久代）是没有垃圾收集的，Java虚拟机规范中确实说过可以不要求虚拟机在方法区实现垃圾收集，而且在方法区中进行垃圾收集的“性价比”一般比较低：在堆中，尤其是在新生代中，常规应用进行一次垃圾收集一般可以回收70%～95%的空间，而永久代的垃圾收集效率远低于此。  
  **永久代的垃圾收集主要回收两部分内容：废弃常量和无用的类**。回收废弃常量与回收Java堆中的对象非常类似。以常量池中字面量的回收为例，假如一个字符串“abc”已经进入了常量池中，但是当前系统没有任何一个String对象是叫做“abc”的，换句话说，就是没有任何String对象引用常量池中的“abc”常量，也没有其他地方引用了这个字面量，如果这时发生内存回收，而且必要的话，这个“abc”常量就会被系统清理出常量池。常量池中的其他类（接口）、方法、字段的符号引用也与此类似。  
  判定一个常量是否是“废弃常量”比较简单，而要判定一个类是否是“无用的类”的条件则相对苛刻许多。类需要**同时满足下面3个条件才能算是“无用的类”：**

1.  该类所有的实例都已经被回收，也就是Java堆中不存在该类的任何实例。
2.  加载该类的ClassLoader已经被回收。
3.  该类对应的java.lang.Class对象没有在任何地方被引用，无法在任何地方通过反射访问该类的方法。

## 垃圾收集算法 ##

垃圾收集算法各个虚拟机操作内存方法不同，此处只简单介绍思想。

### 标记-清除算法 ###

最基础的收集算法是“标记-清除”（Mark-Sweep）算法，算法分为“标记”和“清除”两个阶段，它是最基础的收集算法，后续的收集算法都是基于这种思路并对其不足进行改进而得到的。**它的主要不足有两个：一个是效率问题，标记和清除两个过程的效率都不高；另一个是空间问题，标记清除之后会产生大量不连续的内存碎片，空间碎片太多可能会导致以后在程序运行过程中需要分配较大对象时，无法找到足够的连续内存而不得不提前触发另一次垃圾收集动作**。标记—清除算法的执行过程如图3-2所示。  
      ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTI2MjQ1Mw_size_16_color_FFFFFF_t_70 1]

### 复制算法 ###

为了解决效率问题，一种称为“复制”（Copying）的收集算法出现了，它将可用内存按容量划分为大小相等的两块，每次只使用其中的一块。当这一块的内存用完了，就将还存活着的对象复制到另外一块上面，然后再把已使用过的内存空间一次清理掉。这样使得每次都是对整个半区进行内存回收，内存分配时也就不用考虑内存碎片等复杂情况，只要移动堆顶指针，按顺序分配内存即可，实现简单，运行高效。只是这种算法的代价是将内存缩小为了原来的一半，未免太高了一点。复制算法的执行过程如图3-3所示。  
      ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTI2MjQ1Mw_size_16_color_FFFFFF_t_70 2]  
  现在的**商业虚拟机都采用这种复制收集算法来回收新生代**，新生代中的对象98%是“朝生夕死”的，所以**并不需要按照1:1的比例来划分内存空间，而是将内存分为一块较大的Eden空间和两块较小的Survivor空间，每次使用Eden和其中一块Survivor**。当回收时，将Eden和Survivor中还存活着的对象一次性地复制到另外一块Survivor空间上，最后清理掉Eden和刚才用过的Survivor空间。HotSpot虚拟机默认Eden和Survivor的大小比例是 8:1，也就是每次新生代中可用内存空间为整个新生代容量的90%（80%+10%），只有10%的内存会被“浪费”。当然，98%的对象可回收只是一般场景下的数据，我们没有办法保证每次回收都只有不多于10%的对象存活，**当Survivor空间不够用时，需要依赖其他内存（这里指老年代）进行分配担保**（Handle Promotion）。  
  内存的分配担保就好比我们去银行借款，如果我们信誉很好，在98%的情况下都能按时偿还，于是银行可能会默认我们下一次也能按时按量地偿还贷款，只需要有一个担保人能保证如果我不能还款时，可以从他的账户扣钱，那银行就认为没有风险了。内存的分配担保也一样，如果另外一块Survivor空间没有足够空间存放上一次新生代收集下来的存活对象时，这些对象将直接通过分配担保机制进入老年代。

### 标记-整理算法 ###

复制收集算法在对象存活率较高时就要进行较多的复制操作，效率将会变低。更关键的是，如果不想浪费50%的空间，就需要有额外的空间进行分配担保，以应对被使用的内存中所有对象都100%存活的极端情况，所以在老年代一般不能直接选用这种算法。  
  **根据老年代的特点，有人提出了另外一种“标记-整理”（Mark-Compact）算法，标记过程仍然与“标记-清除”算法一样**，但后续步骤不是直接对可回收对象进行清理，而是让所有存活的对象都向一端移动，然后直接清理掉端边界以外的内存，“标记-整理”算法的示意图如图3-4所示。  
      ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTI2MjQ1Mw_size_16_color_FFFFFF_t_70 3]

### 实际使用的分代收集算法 ###

当前商业虚拟机的垃圾收集都采用“分代收集”（Generational Collection）算法，这种算法并没有什么新的思想，只是根据对象存活周期的不同将内存划分为几块。一般是把Java堆分为新生代和老年代，这样就可以根据各个年代的特点采用最适当的收集算法。**在新生代中**，每次垃圾收集时都发现有大批对象死去，只有少量存活，那就**选用复制算法，只需要付出少量存活对象的复制成本就可以完成收集**。**而老年代中因为对象存活率高、没有额外空间对它进行分配担保，就必须使用“标记—清理”或者“标记—整理”算法来进行回收。**

## HotSpot算法实现 ##

HotSpot是sun jdk中所带的虚拟机，也是使用范围最广的java虚拟机。

## HotSpot中的垃圾收集器 ##

如果说收集算法是内存回收的方法论，那么垃圾收集器就是内存回收的具体实现，不同厂商、不同版本的垃圾收集器会有很大的差别。HotSpot虚拟机的垃圾收集器包含7种垃圾收集器。  
      ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTI2MjQ1Mw_size_16_color_FFFFFF_t_70 4]

### Serial收集器(了解) ###

Serial收集器是最基本、**发展历史最悠久的收集器**，曾经（在JDK 1.3.1之前）是虚拟机新生代收集的唯一选择。这个收集器是一个**单线程**的收集器，**在垃圾收集时会“Stop The World”**，即在用户不可见的情况下把用户正常工作的线程全部停掉。**食之无味弃之可惜，简单而高效，但是系统运行会停顿**。图3-6示意了Serial/Serial Old收集器的运行过程。  
    ![在这里插入图片描述][2019021413093942.png]

### Serial Old收集器(了解) ###

Serial Old是Serial收集器的老年代版本，它**同样是一个单线程收集器，使用“标记-整理”算法。这个收集器的主要意义也是在于给Client模式下的虚拟机使用**。如果在Server模式下，那么它主要还有两大用途：一种用途是在JDK 1.5以及之前的版本中与Parallel Scavenge收集器搭配使用，另一种用途就是作为CMS收集器的后备预案，在并发收集发生Concurrent Mode Failure时使用。Serial Old收集器的工作过程如图3-8所示。  
    ![在这里插入图片描述][20190214131318567.png]

### ParNew收集器(了解) ###

**ParNew收集器其实就是Serial收集器的多线程版本**。ParNew收集器的工作过程如图3-7所示。  
    ![在这里插入图片描述][2019021413143015.png]  
  **ParNew收集器多线程收集、多运行在Server模式下的虚拟机中首选的新生代收集器、除了Serial收集器外，目前只有它能与CMS收集器配合工作**。  
  ParNew收集器**在单CPU的环境中绝对不会有比Serial收集器更好的效果，甚至由于存在线程交互的开销**，该收集器在通过超线程技术实现的两个CPU的环境中都不能百分之百地保证可以超越Serial收集器。当然，**随着可以使用的CPU的数量的增加，它对于GC时系统资源的有效利用还是很有好处的**。它默认开启的收集线程数与CPU的数量相同，在CPU非常多（譬如32个，现在CPU动辄就4核加超线程，服务器超过32个逻辑CPU的情况越来越多了）的环境下，可以使用-XX：ParallelGCThreads参数来限制垃圾收集的线程数。  
  注意：从ParNew收集器开始，后面还会接触到几款并发和并行的收集器。并发和并行，这两个名词都是并发编程中的概念，解释如下。

*  并行（Parallel）：**指多条垃圾收集线程并行工作，但此时用户线程仍然处于等待状态**。
 *  并发（Concurrent）：指用户线程与垃圾收集线程同时执行（但不一定是并行的，可能会交替执行），**用户程序在继续运行，而垃圾收集程序运行于另一个CPU上**。

### Parallel Scavenge收集器(了解) ###

Parallel Scavenge收集器是一个新生代收集器，它也是使用复制算法的收集器，又是**并行的多线程收集器**。 \[ˈskævɪndʒ\]清除污物，打扫;  
  Parallel Scavenge收集器的特点是它的关注点与其他收集器不同，**CMS等收集器的关注点是尽可能地缩短垃圾收集时用户线程的停顿时间，而Parallel Scavenge收集器的目标则是达到一个可控制的吞吐量**。（Throughput）。所谓吞吐量就是CPU用于运行用户代码的时间与CPU总消耗时间的比值，即吞吐量=运行用户代码时间/（运行用户代码时间+垃圾收集时间），虚拟机总共运行了100分钟，其中垃圾收集花掉1分钟，那吞吐量就是99%。  
  停顿时间越短就越适合需要与用户交互的程序，良好的响应速度能提升用户体验，而高吞吐量则可以高效率地利用CPU时间，尽快完成程序的运算任务，主要适合在后台运算而不需要太多交互的任务。  
  Parallel Scavenge收集器提供了两个参数用于精确控制吞吐量，分别是控制最大垃圾收集停顿时间的-XX：MaxGCPauseMillis参数以及直接设置吞吐量大小的-XX：GCTimeRatio参数。

### Parallel Old收集器(了解) ###

Parallel Old是Parallel Scavenge收集器的老年代版本，使用多线程和“标记-整理”算法。这个收集器是在JDK 1.6中才开始提供的，在此之前，新生代的Parallel Scavenge收集器一直处于比较尴尬的状态。原因是，如果新生代选择了Parallel Scavenge收集器，老年代除了Serial Old（PS MarkSweep）收集器外别无选择（还记得上面说过Parallel Scavenge收集器无法与CMS收集器配合工作吗？）。由于老年代Serial Old收集器在服务端应用性能上的“拖累”，使用了Parallel Scavenge收集器也未必能在整体应用上获得吞吐量最大化的效果，由于单线程的老年代收集中无法充分利用服务器多CPU的处理能力，在老年代很大而且硬件比较高级的环境中，这种组合的吞吐量甚至还不一定有ParNew加CMS的组合“给力”。  
  直到Parallel Old收集器出现后，“吞吐量优先”收集器终于有了比较名副其实的应用组合，在注重吞吐量以及CPU资源敏感的场合，都可以优先考虑Parallel Scavenge加Parallel Old收集器。Parallel Old收集器的工作过程如图3-9所示。  
    ![在这里插入图片描述][20190214131908397.png]

### CMS收集器 ###

在JDK 1.5时期，HotSpot推出了一款在强交互应用中几乎可认为**有划时代意义的垃圾收集器——CMS收集器**（Concurrent Mark Sweep，本节稍后将详细介绍这款收集器），这款收集器是HotSpot虚 拟机中第一款真正意义上的并发（Concurrent）收集器，它第一次实现了让垃圾收集线程与用户线程（基本上）同时工作。  
  CMS（Concurrent Mark Sweep）收集器是**一种以获取最短回收停顿时间为目标的收集器**。目前很大一部分的Java应用集中在互联网站或者B/S系统的服务端上，这类应用尤其**重视服务的响应速度**，希望系统停顿时间最短，以给用户带来较好的体验。CMS收集器就非常符合这类应用的需求。  
  从名字（包含“Mark Sweep”）上就可以看出，CMS收集器是基于“标记—清除”算法实现的，**它的运作过程相对于前面几种收集器来说更复杂**一些，整个过程分为4个步骤，包括：

*  初始标记（CMS initial mark）
 *  并发标记（CMS concurrent mark）
 *  重新标记（CMS remark）
 *  并发清除（CMS concurrent sweep）

其中，初始标记、重新标记这两个步骤仍然需要“Stop The World”。初始标记仅仅只是标记一下GC Roots能直接关联到的对象，速度很快，并发标记阶段就是进行GC RootsTracing的过程，而重新标记阶段则是为了修正并发标记期间因用户程序继续运作而导致标记产生变动的那一部分对象的标记记录，这个阶段的停顿时间一般会比初始标记阶段稍长一些，但远比并发标记的时间短。  
  由于整个过程中耗时最长的并发标记和并发清除过程收集器线程都可以与用户线程一起工作，所以，从总体上来说，**CMS收集器的内存回收过程是与用户线程一起并发执行的**。通过图3-10可以比较清楚地看到CMS收集器的运作步骤中并发和需要停顿的时间。  
    ![在这里插入图片描述][20190214133959453.png]  
CMS(Concurrent Mark Sweep)是一款优秀的收集器，它的主要优点在名字上已经体现出来了：**并发收集、低停顿**，Sun公司的一些官方文档中也称之为并发低停顿收集器（Concurrent Low Pause Collector）。但是CMS还远达不到完美的程度，它有以下3个明显的缺点：

*  **CMS收集器对CPU资源非常敏感。其实，面向并发设计的程序都对CPU资源比较敏感**。在并发阶段，它虽然不会导致用户线程停顿，但是会因为占用了一部分线程（或者说CPU资源）而导致应用程序变慢，总吞吐量会降低。CMS默认启动的回收线程数是（CPU数量+3）/4，也就是当CPU在4个以上时，并发回收时垃圾收集线程不少于25%的CPU资源，并且随着CPU数量的增加而下降。但是当CPU不足4个（譬如2个）时，CMS对用户程序的影响就可能变得很大，如果本来CPU负载就比较大，还分出一半的运算能力去执行收集器线程，就可能导致用户程序的执行速度忽然降低了50%，其实也让人无法接受。为了应付这种情况，虚拟机提供了一种称为“增量式并发收集器”（Incremental Concurrent Mark Sweep/i-CMS）的CMS收集器变种，所做的事情和单CPU年代PC机操作系统使用抢占式来模拟多任务机制的思想一样，就是在并发标记、清理的时候让GC线程、用户线程交替运行，尽量减少GC线程的独占资源的时间，这样整个垃圾收集的过程会更长，但对用户程序的影响就会显得少一些，也就是速度下降没有那么明显。实践证明，增量时的CMS收集器效果很一般，在目前版本中，i-CMS已经被声明为“deprecated”，即不再提倡用户使用。
 *  **CMS收集器无法处理浮动垃圾（Floating Garbage），可能出现“Concurrent ModeFailure”失败而导致另一次FullGC的产生**。由于CMS并发清理阶段用户线程还在运行着，伴随程序运行自然就还会有新的垃圾不断产生，这一部分垃圾出现在标记过程之后，CMS无法在当次收集中处理掉它们，只好留待下一次GC时再清理掉。这一部分垃圾就称为“浮动垃圾”。也是由于在垃圾收集阶段用户线程还需要运行，那也就还需要预留有足够的内存空间给用户线程使用，因此CMS收集器不能像其他收集器那样等到老年代几乎完全被填满了再进行收集，需要预留一部分空间提供并发收集时的程序运作使用。在JDK1.5的默认设置下，CMS收集器当老年代使用了68%的空间后就会被激活，这是一个偏保守的设置，如果在应用中老年代增长不是太快，可以适当调高参数-XX：CMSInitiatingOccupancyFraction的值来提高触发百分比，以便降低内存回收次数从而获取更好的性能，在JDK 1.6中，CMS收集器的启动阈值已经提升至92%。要是CMS运行期间预留的内存无法满足程序需要，就会出现一次“Concurrent Mode Failure”失败，这时虚拟机将启动后备预案：临时启用Serial  
    Old收集器来重新进行老年代的垃圾收集，这样停顿时间就很长了。所以说参数-XX：CMSInitiatingOccupancyFraction设置得太高很容易导致大量“Concurrent  
    Mode Failure”失败，性能反而降低。
 *  还有最后一个缺点，在本节开头说过，CMS是一款基于“标记—清除”算法实现的收集器，如果读者对前面这种算法介绍还有印象的话，就可能想到这意味着**收集结束时会有大量空间碎片产生**。空间碎片过多时，将会给大对象分配带来很大麻烦，往往会出现老年代还有很大空间剩余，但是无法找到足够大的连续空间来分配当前对象，不得不提前触发一次Full GC。为了解决这个问题，CMS收集器提供了一个-XX：+UseCMSCompactAtFullCollection开关参数（默认就是开启的），用于在CMS收集器顶不住要进行FullGC时开启内存碎片的合并整理过程，内存整理的过程是无法并发的，空间碎片问题没有了，但停顿时间不得不变长。虚拟机设计者还提供了另外一个参数-XX：CMSFullGCsBeforeCompaction，这个参数是用于设置执行多少次不压缩的Full GC后，跟着来一次带压缩的（默认值为0，表示每次进入Full GC时都进行碎片整理）。

### G1收集器 ###

**G1（Garbage-First）收集器是当今收集器技术发展的最前沿成果之一，它就被视为JDK 1.7中HotSpot虚拟机的一个重要进化特征。G1是一款面向服务端应用的垃圾收集器**。HotSpot开发团队赋予它的使命是（在比较长期的）未来可以替换掉JDK 1.5中发布的CMS收集器。与其他GC收集器相比，G1具备如下特点。  
  **并行与并发**：G1能充分利用多CPU、多核环境下的硬件优势，使用多个CPU（CPU或者CPU核心）来缩短Stop-The-World停顿的时间，部分其他收集器原本需要停顿Java线程执行的GC动作，G1收集器仍然可以通过并发的方式让Java程序继续执行。  
 &\#8195\*\*;分代收集\*\*：与其他收集器一样，分代概念在G1中依然得以保留。虽然G1可以不需要其他收集器配合就能独立管理整个GC堆，但它能够采用不同的方式去处理新创建的对象和已经存活了一段时间、熬过多次GC的旧对象以获取更好的收集效果。  
  **空间整合**：与CMS的“标记—清理”算法不同，**G1从整体来看是基于“标记—整理”算法实现的收集器，从局部（两个Region之间）上来看是基于“复制”算法实现的**，但无论如何，这两种算法都意味着**G1运作期间不会产生内存空间碎片，收集后能提供规整的可用内存**。这种特性有利于程序长时间运行，分配大对象时不会因为无法找到连续内存空间而提前触发下一次GC。  
  **可预测的停顿**：这是G1相对于CMS的另一大优势，**降低停顿时间是G1和CMS共同的关注点，但G1除了追求低停顿外，还能建立可预测的停顿时间模型**，能让使用者明确指定在一个长度为M毫秒的时间片段内，消耗在垃圾收集上的时间不得超过N毫秒，这几乎已经是实时Java（RTSJ）的垃圾收集器的特征了。  
  在G1之前的其他收集器进行收集的范围都是整个新生代或者老年代，而G1不再是这样。使用G1收集器时，Java堆的内存布局就与其他收集器有很大差别，它将整个Java堆划分为多个大小相等的独立区域（Region），虽然还保留有新生代和老年代的概念，但新生代和老年代不再是物理隔离的了，它们都是一部分Region（不需要连续）的集合。  
  G1收集器之所以能建立可预测的停顿时间模型，是因为它可以有计划地避免在整个Java堆中进行全区域的垃圾收集。G1跟踪各个Region里面的垃圾堆积的价值大小（回收所获得的空间大小以及回收所需时间的经验值），在后台维护一个优先列表，每次根据允许的收集时间，优先回收价值最大Region（这也就是Garbage-First名称的来由）。这种使用Region划分内存空间以及有优先级的区域回收方式，保证了G1收集器在有限的时间内可以获取尽可能高的收集效率。通过图3-11可以比较清楚地看到G1收集器的运作步骤中并发和需要停顿的阶段。  
![在这里插入图片描述][20190214135500502.png]

## GC日志含义 ##

33.125：[GC[DefNew：3324K-＞152K（3712K），0.0025925 secs]3324K-＞152K（11904K），0.0031680 secs]
    100.667：[FullGC[Tenured：0K-＞210K（10240K），0.0 149142secs]4603K-＞210K（19456K），[Perm：2999K-＞
    2999K（21248K）]，0.0150007 secs][Times：user=0.01 sys=0.00，real=0.02 secs]

最前面的数字“33.125：”和“100.667：”代表了GC发生的时间，这个数字的含义是从Java虚拟机启动以来经过的秒数。  
  GC日志开头的“\[GC”和“\[Full GC”说明了这次垃圾收集的停顿类型，而不是用来区分新生代GC还是老年代GC的。如果有“Full”，说明这次GC是发生了Stop-The-World的，例如下面这段新生代收集器ParNew的日志也会出现“\[Full GC”（这一般是因为出现了分配担保失败之类的问题，所以才导致STW）。如果是调用System.gc()方法所触发的收集，那么在这里将显示“\[Full GC（System）”

[Full GC 283.736：[ParNew：261599K-＞261599K（261952K），0.0000288 secs]

接下来的“\[DefNew”、“\[Tenured”、“\[Perm”表示GC发生的区域，这里显示的区域名称与使用的GC收集器是密切相关的，例如上面样例所使用的Serial收集器中的新生代名为“Default New Generation”，所以显示的是“\[DefNew”。如果是ParNew收集器，新生代名称就会变为“\[ParNew”，意为“Parallel New Generation”。如果采用Parallel Scavenge收集器，那它配套的新生代称为“PSYoungGen”，老年代和永久代同理，名称也是由收集器决定的。  
  后面方括号内部的“3324K-＞152K（3712K）”含义是“GC前该内存区域已使用容量-＞GC后该内存区域已使用容量（该内存区域总容量）”。而在方括号之外的“3324K-＞152K（11904K）”表示“GC前Java堆已使用容量-＞GC后Java堆已使用容量（Java堆总容量）”。  
  再往后，“0.0025925 secs”表示该内存区域GC所占用的时间，单位是秒。有的收集器会给出更具体的时间数据，如“\[Times：user=0.01 sys=0.00，real=0.02 secs\]”，这里面的user、sys和real与Linux的time命令所输出的时间含义一致，分别代表用户态消耗的CPU时间、内核态消耗的CPU事件和操作从开始到结束所经过的墙钟时间（Wall Clock Time）。CPU时间与墙钟时间的区别是，墙钟时间包括各种非运算的等待耗时，例如等待磁盘I/O、等待线程阻塞，而CPU时间不包括这些耗时，但当系统有多CPU或者多核的话，多线程操作会叠加这些CPU时间，所以读者看到user或sys时间超过real时间是完全正常的。

## 虚拟机实现内存分配的几条原则 ##

对象的内存分配，往大方向讲，就是在堆上分配（但也可能经过JIT编译后被拆散为标量类型并间接地栈上分配），**对象主要分配在新生代的Eden区上，如果启动了本地线程分配缓冲，将按线程优先在TLAB上分配。少数情况下也可能会直接分配在老年代中，分配的规则并不是百分之百固定的，其细节取决于当前使用的是哪一种垃圾收集器组合，还有虚拟机中与内存相关的参数的设置**。  
  接下来我们将会讲解几条最普遍的内存分配规则，并通过代码去验证这些规则。本节下面的代码在测试时使用Client模式虚拟机运行，没有手工指定收集器组合，换句话说，验证的是在使用Serial/Serial Old收集器下（ParNew/Serial Old收集器组合的规则也基本一致）的内存分配和回收的策略。

### 对象优先在Eden分配 ###

大多数情况下，对象在新生代Eden区中分配。当Eden区没有足够空间进行分配时，虚拟机将发起一次Minor GC。  
  虚拟机提供了-XX：+PrintGCDetails这个收集器日志参数，告诉虚拟机在发生垃圾收集行为时打印内存回收日志，并且在进程退出的时候输出当前的内存各区域分配情况。VM参数：-Xms20M -Xmx20M -Xmn10M -XX:+PrintGCDetails

public class TestMinorGC { 
    	private static final int _1MB = 1024*1024;
    		/** *VM参数：-verbose:gc -Xms20M -Xmx20M -Xmn10M -XX:+PrintGCDetails -XX:SurvivorRatio=8 */
    		public static void testAllocation(){ 
    			byte[]allocation1,allocation2,allocation3,allocation4;
    			allocation1 = new byte[2*_1MB];
    			allocation2 = new byte[2*_1MB];
    			allocation3 = new byte[2*_1MB];
    			allocation4 = new byte[4*_1MB];//出现一次Minor GC
    		}
    		public static void main(String[] args) { 
    			TestMinorGC.testAllocation();
    		}
    }

理想运行结果：

[GC[DefNew：6651K-＞148K（9216K），0.0070106 secs]6651K-＞6292K（19456K），0.0070426 secs][Times：user=0.00 sys=0.00，real=0.00 secs]
    Heap
    def new generation total 9216K,used 4326K[0x029d0000，0x033d0000，0x033d0000）
    eden space 8192K，51%used[0x029d0000，0x02de4828，0x031d0000）
    from space 1024K，14%used[0x032d0000，0x032f5370，0x033d0000）
    to space 1024K，0%used[0x031d0000，0x031d0000，0x032d0000）
    tenured generation total 10240K,used 6144K[0x033d0000，0x03dd0000，0x03dd0000）
    the space 10240K，60%used[0x033d0000，0x039d0030，0x039d0200，0x03dd0000）
    compacting perm gen total 12288K,used 2114K[0x03dd0000，0x049d0000，0x07dd0000）
    the space 12288K，17%used[0x03dd0000，0x03fe0998，0x03fe0a00，0x049d0000）
    No shared spaces configured.

代码清单3-5的testAllocation（）方法中，尝试分配3个2MB大小和1个4MB大小的对象，在运行时通过-Xms20M、-Xmx20M、-Xmn10M这3个参数限制了Java堆大小为20MB，不可扩展，其中10MB分配给新生代，剩下的10MB分配给老年代。-XX：SurvivorRatio=8决定了新生代中Eden区与一个Survivor区的空间比例是8:1，从输出的结果也可以清晰地看到“eden space 8192K、from space 1024K、to space 1024K”的信息，新生代总可用空间为9216KB（Eden区+1个Survivor区的总容量）。  
  执行testAllocation（）中分配allocation4对象的语句时会发生一次Minor GC，这次GC的结果是新生代6651KB变为148KB，而总内存占用量则几乎没有减少（因为allocation1、allocation2、allocation3三个对象都是存活的，虚拟机几乎没有找到可回收的对象）。这次GC发生的原因是给allocation4分配内存的时候，发现Eden已经被占用了6MB，剩余空间已不足以分配allocation4所需的4MB内存，因此发生Minor GC。GC期间虚拟机又发现已有的3个2MB大小的对象全部无法放入Survivor空间（Survivor空间只有1MB大小），所以只好通过分配担保机制提前转移到老年代去。  
  这次GC结束后，4MB的allocation4对象顺利分配在Eden中，因此程序执行完的结果是Eden占用4MB（被allocation4占用），Survivor空闲，老年代被占用6MB（被allocation1、allocation2、allocation3占用）。通过GC日志可以证实这一点。eden space 8192K，51%used ，eden 8M内存被allocation4占了， tenured generation 10M内存被allocation1、allocation2、allocation3占用。

注意：Minor GC和Full GC有什么不一样吗？

*  **新生代GC（Minor GC）：指发生在新生代的垃圾收集动作，因为Java对象大多都具备朝生夕灭的特性**，所以Minor GC非常频繁，一般回收速度也比较快。
 *  **老年代GC（Major GC/Full GC）**：指发生在老年代的GC，出现了Major GC，经常会伴随至少一次的Minor GC（但非绝对的，在Parallel Scavenge收集器的收集策略里就有直接进行Major GC的策略选择过程）。**Major 的速度一般会比Minor GC慢10倍以上。**

### 大对象直接进入老年代 ###

**所谓的大对象是指，需要大量连续内存空间的Java对象，最典型的大对象就是那种很长的字符串以及数组**（笔者列出的例子中的byte\[\]数组就是典型的大对象）。大对象对虚拟机的内存分配来说就是一个坏消息（替Java虚拟机抱怨一句，比遇到一个大对象更加坏的消息就是遇到一群“朝生夕灭”的“短命大对象”，写程序的时候应当避免），**经常出现大对象容易导致内存还有不少空间时就提前触发垃圾收集以获取足够的连续空间来“安置”它们**。  
  **虚拟机提供了一个-XX：PretenureSizeThreshold参数，令大于这个设置值的对象直接在老年代分配。这样做的目的是避免在Eden区及两个Survivor区之间发生大量的内存复制（复习一下：新生代采用复制算法收集内存）。**

public class TestBigObject { 
    	private static final int _1MB=1024*1024;
    	/** *VM参数：-verbose:gc -Xms20M -Xmx20M -Xmn10M -XX:+PrintGCDetails -XX:SurvivorRatio=8 -XX:PretenureSizeThreshold=3145728 */
    	public static void testPretenureSizeThreshold(){ 
    		byte[]allocation;
    		allocation=new byte[4*_1MB];//直接分配在老年代中
    	}
    	public static void main(String[] args) { 
    		TestBigObject.testPretenureSizeThreshold();
    	}
    }

理想运行结果：书中的结果

Heap
    def new generation total 9216K,used 671K[0x029d0000，0x033d0000，0x033d0000）
    eden space 8192K，8%used[0x029d0000，0x02a77e98，0x031d0000）
    from space 1024K，0%used[0x031d0000，0x031d0000，0x032d0000）
    to space 1024K，0%used[0x032d0000，0x032d0000，0x033d0000）
    tenured generation total 10240K,used 4096K[0x033d0000，0x03dd0000，0x03dd0000）
    the space 10240K，40%used[0x033d0000，0x037d0010，0x037d0200，0x03dd0000）
    compacting perm gen total 12288K,used 2107K[0x03dd0000，0x049d0000，0x07dd0000）
    the space 12288K，17%used[0x03dd0000，0x03fdefd0，0x03fdf000，0x049d0000）
    No shared spaces configured.

执行代码清单3-6中的testPretenureSizeThreshold（）方法后，我们看到Eden空间几乎没有被使用，而老年代的10MB空间被使用了40%，也就是4MB的allocation对象直接就分配在老年代中，这是因为PretenureSizeThreshold被设置为3MB（就是3145728，这个参数不能像-Xmx之类的参数一样直接写3MB），因此超过3MB的对象都会直接在老年代进行分配。注意PretenureSizeThreshold参数只对Serial和ParNew两款收集器有效，Parallel Scavenge收集器不认识这个参数，Parallel Scavenge收集器一般并不需要设置。如果遇到必须使用此参数的场合，可以考虑ParNew加CMS的收集器组合。  
  实际上我运行的结果：想不明白

Heap
     PSYoungGen      total 9216K, used 5244K [0x00000000ff600000, 0x0000000100000000, 0x0000000100000000)
      eden space 8192K, 64% used [0x00000000ff600000,0x00000000ffb1f308,0x00000000ffe00000)
      from space 1024K, 0% used [0x00000000fff00000,0x00000000fff00000,0x0000000100000000)
      to   space 1024K, 0% used [0x00000000ffe00000,0x00000000ffe00000,0x00000000fff00000)
     ParOldGen       total 10240K, used 0K [0x00000000fec00000, 0x00000000ff600000, 0x00000000ff600000)
      object space 10240K, 0% used [0x00000000fec00000,0x00000000fec00000,0x00000000ff600000)
     Metaspace       used 2733K, capacity 4486K, committed 4864K, reserved 1056768K
      class space    used 304K, capacity 386K, committed 512K, reserved 1048576K

### 长期存活的对象将进入老年代 ###

既然虚拟机采用了分代收集的思想来管理内存，那么内存回收时就必须能识别哪些对象应放在新生代，哪些对象应放在老年代中。为了做到这点，**虚拟机给每个对象定义了一个对象年龄（Age）计数器。如果对象在Eden出生并经过第一次Minor GC后仍然存活，并且能被Survivor容纳的话，将被移动到Survivor空间中，并且对象年龄设为1。对象在Survivor区中每“熬过”一次Minor GC，年龄就增加1岁，当它的年龄增加到一定程度（默认为15岁），就将会被晋升到老年代中**。对象晋升老年代的年龄阈值，可以通过参数-XX：MaxTenuringThreshold设置。

public class TestLongTimeSurvival { 
    	private static final int _1MB=1024*1024;
    	/** *VM参数：-verbose:gc -Xms20M -Xmx20M -Xmn10M -XX:+PrintGCDetails -XX:SurvivorRatio=8 -XX:MaxTenuringThreshold=1 -XX:+PrintTenuringDistribution */
    	@SuppressWarnings("unused")
    	public static void testTenuringThreshold(){ 
    		byte[]allocation1,allocation2,allocation3;
    		allocation1=new byte[_1MB/4];
    		//什么时候进入老年代取决于XX：MaxTenuringThreshold设置
    		allocation2=new byte[4*_1MB];
    		allocation3=new byte[4*_1MB];
    		allocation3=null;
    		allocation3=new byte[4*_1MB];
    	}
    	public static void main(String[] args) { 
    		TestLongTimeSurvival.testTenuringThreshold();
    	}
    }

此方法中的allocation1对象需要256KB内存，Survivor空间可以容纳。当MaxTenuringThreshold=1时，allocation1对象在第二次GC发生时从Survivor进入老年代，新生代 from space已使用的内存GC后非常干净地变成0KB。而MaxTenuringThreshold=15时，第二次GC发生后，allocation1对象则还留在新生代Survivor空间，这时新生代仍然有404KB被占用。  
  理想的当MaxTenuringThreshold=1时：

[GC[DefNew
    Desired Survivor size 524288 bytes,new threshold 1（max 1）
    -age 1：414664 bytes，414664 total ：4859K-＞404K（9216K），0.0065012 secs]4859K-＞4500K（19456K），0.0065283 secs][Times：user=0.02 sys=0.00，real=0.02 secs]
    [GC[DefNew
    Desired Survivor size 524288 bytes,new threshold 1（max 1）
    ：4500K-＞0K（9216K），0.0009253 secs]8596K-＞4500K（19456K），0.0009458 secs][Times：user=0.00 sys=0.00，real=0.00 secs]
    Heap
    def new generation total 9216K,used 4178K[0x029d0000，0x033d0000，0x033d0000）
    eden space 8192K，51%used[0x029d0000，0x02de4828，0x031d0000）
    from space 1024K，0%used[0x031d0000，0x031d0000，0x032d0000）
    to space 1024K，0%used[0x032d0000，0x032d0000，0x033d0000）
    tenured generation total 10240K,used 4500K[0x033d0000，0x03dd0000，0x03dd0000）
    the space 10240K，43%used[0x033d0000，0x03835348，0x03835400，0x03dd0000）
    compacting perm gen total 12288K,used 2114K[0x03dd0000，0x049d0000，0x07dd0000）
    the space 12288K，17%used[0x03dd0000，0x03fe0998，0x03fe0a00，0x049d0000）
    No shared spaces configured.

理想的当MaxTenuringThreshold=15时，结果如下，Survivor容纳的 allocation1年龄阈值为15，所以最终会呆在 from space中。allocation2发生Minor GC时，Suvivor已经不能容纳它，所以放到老年代中。

[GC[DefNew
    Desired Survivor size 524288 bytes,new threshold 15（max 15）
    -age 1：414664 bytes，414664 total ：4859K-＞404K（9216K），0.0049637 secs]4859K-＞4500K（19456K），0.0049932 secs][Times：user=0.00 sys=0.00，real=0.00 secs]
    [GC[DefNew
    Desired Survivor size 524288 bytes,new threshold 15（max 15）
    -age 2：414520 bytes，414520 total ：4500K-＞404K（9216K），0.0008091 secs]8596K-＞4500K（19456K），0.0008305 secs][Times：user=0.00 sys=0.00，real=0.00 secs]
    Heap
    def new generation total 9216K,used 4582K[0x029d0000，0x033d0000，0x033d0000）
    eden space 8192K，51%used[0x029d0000，0x02de4828，0x031d0000）
    from space 1024K，39%used[0x031d0000，0x03235338，0x032d0000）
    to space 1024K，0%used[0x032d0000，0x032d0000，0x033d0000）
    tenured generation total 10240K,used 4096K[0x033d0000，0x03dd0000，0x03dd0000）
    the space 10240K，40%used[0x033d0000，0x037d0010，0x037d0200，0x03dd0000）
    compacting perm gen total 12288K,used 2114K[0x03dd0000，0x049d0000，0x07dd0000）
    the space 12288K，17%used[0x03dd0000，0x03fe0998，0x03fe0a00，0x049d0000）
    No shared spaces configured.

### 动态对象年龄判定 ###

为了能更好地适应不同程序的内存状况，**虚拟机并不是永远地要求对象的年龄必须达到了MaxTenuringThreshold才能晋升老年代，如果在Survivor空间中相同年龄所有对象大小的总和大于Survivor空间的一半，年龄大于或等于该年龄的对象就可以直接进入老年代，无须等到MaxTenuringThreshold中要求的年龄。**  
  执行代码清单3-8中的testTenuringThreshold2（）方法，并设置-XX：  
MaxTenuringThreshold=15，会发现运行结果中Survivor的空间占用仍然为0%，而老年代比预期增加了6%，也就是说，allocation1、allocation2对象都直接进入了老年代，而没有等到15岁的临界年龄。因为这两个对象加起来已经到达了512KB，并且它们是同年的，满足同年对象达到Survivor空间的一半规则。我们只要注释掉其中一个对象new操作，就会发现另外一个就不会晋升到老年代中去了。

public class TestDynamicObjectAge { 
    	private static final int _1MB=1024*1024;
    	/** *VM参数：-verbose:gc-Xms20M -Xmx20M -Xmn10M -XX:+PrintGCDetails -XX:SurvivorRatio=8 -XX:MaxTenuringThreshold=15 -XX:+PrintTenuringDistribution */
    	@SuppressWarnings("unused")
    	public static void testTenuringThreshold2(){ 
    		byte[]allocation1,allocation2,allocation3,allocation4;
    		allocation1=new byte[_1MB/4];
    		//allocation1+allocation2大于survivo空间一半
    		allocation2=new byte[_1MB/4];
    		allocation3=new byte[4*_1MB];
    		allocation4=new byte[4*_1MB];
    		allocation4=null;
    		allocation4=new byte[4*_1MB];
    	}
    	public static void main(String[] args) { 
    		TestDynamicObjectAge.testTenuringThreshold2();
    	}
    }

运行结果：

[GC[DefNew
    Desired Survivor size 524288 bytes,new threshold 1（max 15）
    -age 1：676824 bytes，676824 total ：5115K-＞660K（9216K），0.0050136 secs]5115K-＞4756K（19456K），0.0050443 secs][Times：user=0.00 sys=0.01，real=0.01 secs]
    [GC[DefNew
    Desired Survivor size 524288 bytes,new threshold 15（max 15）
    ：4756K-＞0K（9216K），0.0010571 secs]8852K-＞4756K（19456K），0.0011009 secs][Times：user=0.00 sys=0.00，real=0.00 secs]
    Heap
    def new generation total 9216K,used 4178K[0x029d0000，0x033d0000，0x033d0000）
    eden space 8192K，51%used[0x029d0000，0x02de4828，0x031d0000）
    from space 1024K，0%used[0x031d0000，0x031d0000，0x032d0000）
    to space 1024K，0%used[0x032d0000，0x032d0000，0x033d0000）
    tenured generation total 10240K,used 4756K[0x033d0000，0x03dd0000，0x03dd0000）
    the space 10240K，46%used[0x033d0000，0x038753e8，0x03875400，0x03dd0000）
    compacting perm gen total 12288K,used 2114K[0x03dd0000，0x049d0000，0x07dd0000）
    the space 12288K，17%used[0x03dd0000，0x03fe09a0，0x03fe0a00，0x049d0000）
    No shared spaces configured.

### 空间分配担保 ###

**在发生Minor GC之前，虚拟机会先检查老年代最大可用的连续空间是否大于新生代所有对象总空间，如果这个条件成立，那么Minor GC可以确保是安全的。如果不成立，则虚拟机会查看HandlePromotionFailure设置值是否允许担保失败。如果允许，那么会继续检查老年代最大可用的连续空间是否大于历次晋升到老年代对象的平均大小，如果大于，将尝试着进行一次Minor GC，尽管这次Minor GC是有风险的；如果小于，或者HandlePromotionFailure设置不允许冒险，那这时也要改为进行一次Full GC**。  
  下面解释一下“冒险”是冒了什么风险，前面提到过，新生代使用复制收集算法，但为了内存利用率，只使用其中一个Survivor空间来作为轮换备份，因此当出现大量对象在Minor GC后仍然存活的情况（最极端的情况就是内存回收后新生代中所有对象都存活），就需要老年代进行分配担保，把Survivor无法容纳的对象直接进入老年代。与生活中的贷款担保类似，老年代要进行这样的担保，前提是老年代本身还有容纳这些对象的剩余空间，一共有多少对象会活下来在实际完成内存回收之前是无法明确知道的，所以只好取之前每一次回收晋升到老年代对象容量的平均大小值作为经验值，与老年代的剩余空间进行比较，决定是否进行Full GC来让老年代腾出更多空间。  
  取平均值进行比较其实仍然是一种动态概率的手段，也就是说，如果某次Minor GC存活后的对象突增，远远高于平均值的话，依然会导致担保失败（Handle Promotion Failure）。如果出现了HandlePromotionFailure失败，那就只好在失败后重新发起一次Full GC。虽然担保失败时绕的圈子是最大的，但大部分情况下都还是会将HandlePromotionFailure开关打开，避免Full GC过于频繁，参见代码清单3-9，请读者在JDK 6 Update 24之前的版本中运行测试。

public class TestSpaceAllocationGuarantee { 
    	private static final int _1MB=1024*1024;
    	/** *VM参数：-Xms20M-Xmx20M-Xmn10M-XX：+PrintGCDetails-XX：SurvivorRatio=8-XX：-HandlePromotionFailure */
    	@SuppressWarnings("unused")
    	public static void testHandlePromotion(){ 
    	byte[]allocation1,allocation2,allocation3,allocation4,allocation5,allocation6,allocation7;
    		allocation1=new byte[2*_1MB];
    		allocation2=new byte[2*_1MB];
    		allocation3=new byte[2*_1MB];
    		allocation1=null;
    		allocation4=new byte[2*_1MB];
    		allocation5=new byte[2*_1MB];
    		allocation6=new byte[2*_1MB];
    		allocation4=null;
    		allocation5=null;
    		allocation6=null;
    		allocation7=new byte[2*_1MB];
    	}
    	public static void main(String[] args) { 
    		TestSpaceAllocationGuarantee.testHandlePromotion();
    	}
    }

以HandlePromotionFailure=false参数来运行的结果：

[GC[DefNew：6651K-＞148K（9216K），0.0078936 secs]6651K-＞4244K（19456K），0.0079192 secs][Times：user=0.00 sys=0.02，real=0.02 secs]
    [G C[D e f N e w：6 3 7 8 K-＞6 3 7 8 K（9 2 1 6 K），0.0 0 0 0 2 0 6 s e c s][T e n u r e d：4096K-＞4244K（10240K），0.0042901 secs]10474K-＞
    4244K（19456K），[Perm：2104K-＞2104K（12288K）]，0.0043613 secs][Times：user=0.00 sys=0.00，real=0.00 secs]

以HandlePromotionFailure=true参数来运行的结果：

[GC[DefNew：6651K-＞148K（9216K），0.0054913 secs]6651K-＞4244K（19456K），0.0055327 secs][Times：user=0.00 sys=0.00，real=0.00 secs]
    [GC[DefNew：6378K-＞148K（9216K），0.0006584 secs]10474K-＞4244K（19456K），0.0006857 secs][Times：user=0.00 sys=0.00，real=0.00 secs]

在JDK 6 Update 24之后，这个测试结果会有差异，HandlePromotionFailure参数不会再影响到虚拟机的空间分配担保策略，观察OpenJDK中的源码变化（见代码清单3-10），虽然源码中还定义了HandlePromotionFailure参数，但是在代码中已经不会再使用它。JDK 6 Update 24之后的规则变为只要老年代的连续空间大于新生代对象总大小或者历次晋升的平均大小就会进行Minor GC，否则将进行Full GC。  
代码清单3-10　HotSpot中空间分配检查的代码片段

bool TenuredGeneration：promotion_attempt_is_safe（size_t
    max_promotion_in_bytes）const{
    //老年代最大可用的连续空间
    size_t available=max_contiguous_available（）；
    //每次晋升到老年代的平均大小
    size_t av_promo=（size_t）gc_stats（）-＞avg_promoted（）-＞padded_average（）；
    //老年代可用空间是否大于平均晋升大小，或者老年代可用空间是否大于当此GC时新生代所有对象容量
    bool res=（available＞=av_promo）||（available＞=
    max_promotion_in_bytes）；
    return res；
    }

## 本章小结 ##

本章介绍了垃圾收集的算法、几款JDK 1.7中提供的垃圾收集器特点以及运作原理。通过代码实例验证了Java虚拟机中自动内存分配及回收的主要规则。  
  **内存回收与垃圾收集器在很多时候都是影响系统性能、并发能力的主要因素之一，虚拟机之所以提供多种不同的收集器以及提供大量的调节参数，是因为只有根据实际应用需求、实现方式选择最优的收集方式才能获取最高的性能**。没有固定收集器、参数组合，也没有最优的调优方法，虚拟机也就没有什么必然的内存回收行为。因此，**学习虚拟机内存知识，如果要到实践调优阶段，那么必须了解每个具体收集器的行为、优势和劣势、调节参数。**

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTI2MjQ1Mw_size_16_color_FFFFFF_t_70]: /images/20220320/a105bd00c5e64298906188b15604ff99.png
[20190214103547488.png]: /images/20220320/9343756fe89d457ab8055b598db73be2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTI2MjQ1Mw_size_16_color_FFFFFF_t_70 1]: /images/20220320/7ff809f2933c46d4a296f5202da402c2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTI2MjQ1Mw_size_16_color_FFFFFF_t_70 2]: /images/20220320/0908f6ab14de41e68f75aa20e4ccc1b6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTI2MjQ1Mw_size_16_color_FFFFFF_t_70 3]: /images/20220320/960f2c69b6ae435ca3497b00f7b75f51.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTI2MjQ1Mw_size_16_color_FFFFFF_t_70 4]: /images/20220320/2c7c1541b73d42b49b2339d059ea0f39.png
[2019021413093942.png]: /images/20220320/daacc960336d43bcbbbdd949792fd3d7.png
[20190214131318567.png]: /images/20220320/65f6ce6365a243a3a513dbd5e0228191.png
[2019021413143015.png]: /images/20220320/501250e8d28f448ea7f62f4bf4cadc5d.png
[20190214131908397.png]: /images/20220320/f78d0a06efeb4d78a5d2287561d13532.png
[20190214133959453.png]: /images/20220320/62135f88d39d4bf88cf955f6d2b7be31.png
[20190214135500502.png]: /images/20220320/7002fafa58734a068a010fe3fa9dd09e.png