JVM理论与实践【堆内存结构与垃圾回收】

在生产环境下，通常都需要对JVM进行参数优化，其中对垃圾回收器的参数优化是一个非常重要的一方面。下面重点介绍Java的堆内存，垃圾回收算法，常用的垃圾回收器以及Java堆内存的分配策略，这些内容将作为对JVM进行垃圾回收参数优化的重要基础。然后通过简单示例验证Java的垃圾回收机制。

 

【Java堆内存结构】

       Java的堆(Heap)是存放对象的内存区域。在逻辑上我们可以把堆细分为新生代(Young Generation)、老年代(Old Generation)和永久代(Permanent Generation)。

  1.  新生代：可以再划分为Eden(伊甸)、From Survivor(存活者)和To Survivor三个逻辑区域， 对象优先存放在新生代的Eden区域。

  2. 老年代：新生代的对象经过几次垃圾回收之后，仍然存活的将存放到老年代，并且大对象可以不经过新生代而直接存放在老年代。

  3. 永久代：方法区使用永久代作为存储区域，在逻辑上，永久代是Java堆的一部分、但通常称之为“非堆”(Non-Heap)内存以示区别。方法区(Method Area)通常用来存放类的相关信息 (类加载器所加载的类的字段、方法签名等)、运行时常量池(如字符串常量池)、静态引用变量等。

    Java的堆内存结构可下图简单描述，其中Eden、From Survivor和To Survivor区域这三部分将构成堆内存中的新生堆区域。

 【对象是否存活】

       在进行垃圾回收(Garbage Collection，GC)之前，需要判断堆中哪些对象是可回收的(不再被引用的)、哪些对象是不能被回收的。在面向对象的语言中，通常使用如下两种方式来进行对象是否存活的判断。

  1. 引用计数法：Reference Counting

    可以给每个对象添加引用计数器，对象有新的引用时、计数器+1操作，引用失效时、计数器-1操作，计数器的值为0时、该对象就是可回收的。Python语言的垃圾回收机制就采用引用计数法，但是这种方法很难解决对象的循环引用问题。

  2. 根搜索算法：GC Roots Tracing

    如果对象到GC Roots(比如，线程栈中的对象、静态引用变量等就可作为GC Roots)之间有引用链相连，表示该对象仍然被使用着的、不能被回收的，否则即认为对象没有被引用、是可以进行回收的。典型的高级语言如Java、C#都采用该方法。为了说明Java语言确实是采用根搜索算法判断对象是否存活的，编写程序： 

Java代码  

1. public class CircularRefTest {  
2.     private CircularRefTest instance = null;  
3.     private byte[] buffer = new byte[1024 * 1024];  
4.       
5.     public static void main(String[] args) {  
6.         CircularRefTest a = new CircularRefTest();  
7.         CircularRefTest b = new CircularRefTest();  
8.         a.instance = b;  
9.         b.instance = a;  
10.         a = null;  
11.         b = null;  
12.         System.gc();  
13.     }  
14. }       

     设置该程序运行时的VM Arguments参数：  

Text代码  

1. -Xms3m -Xmx3m -XX:+PrintGCDetails  

     运行该程序，可看到控制台输出内容： 

Text代码  

1. 2014-09-13T16:07:35.998+0800: [GC [DefNew: 623K->64K(960K), 0.0028993 secs][Tenured: 1407K->1471K(2048K), 0.0045221 secs] 1647K->1471K(3008K), [Perm : 1732K->1732K(12288K)], 0.0075367 secs] [Times: user=0.00 sys=0.00, real=0.00 secs]   
2. 2014-09-13T16:07:35.998+0800: [Full GC (System) [Tenured: 2495K->446K(3484K), 0.0050437 secs] 2536K->446K(4636K), [Perm : 1734K->1734K(12288K)], 0.0051196 secs] [Times: user=0.02 sys=0.00, real=0.02 secs]   
3. Heap  
4.  def new generation   total 1664K, used 15K [0x02a50000, 0x02c10000, 0x02c50000)  
5.   eden space 1536K,   1% used [0x02a50000, 0x02a53dd8, 0x02bd0000)  
6.   from space 128K,   0% used [0x02bd0000, 0x02bd0000, 0x02bf0000)  
7.   to   space 128K,   0% used [0x02bf0000, 0x02bf0000, 0x02c10000)  
8.  tenured generation   total 3484K, used 446K [0x02c50000, 0x02fb7000, 0x03050000)  
9.    the space 3484K,  12% used [0x02c50000, 0x02cbf9d0, 0x02cbfa00, 0x02fb7000)  
10.  compacting perm gen  total 12288K, used 1739K [0x03050000, 0x03c50000, 0x07050000)  
11.    the space 12288K,  14% used [0x03050000, 0x03202e80, 0x03203000, 0x03c50000)  
12. No shared spaces configured.  

     说明：在该程序中，先后定义了两个对象，并且每个对象先后被引用了两次，然后每个对象其中的一个引用失效，如果采用引用计数法，这两个对象是不能被回收的，因为每个对象都还有一个未失效的引用。但是通过控制台的观察发现，这两个对象确实是被回收了的，这说明Java并未采用引用计数法。在上述程序中，引用变量a和b是线程栈引用变量，都可以作为GC Roots，a和b先后被置为null，这意味着对象通过instance引用无法和GC Roots建立一个有效的引用链，因此这两个对象都被回收了。这说明Java确实是采用根搜索算法来判断对象是否可回收的。

 

【引用类型的扩展】

     强引用(Strong)：传统意义的引用。

     软引用(soft)：在内存紧张时、会回收软引用对象(结合使用SoftReference类)。

     弱引用：对象只能生存到下一次垃圾回收之前。

     虚引用：引用关系最弱、无法通过虚引用获取对象。

Java代码  

1. public class SoftRefTest {  
2.     private byte[] buffer = new byte[2 * 1024 * 1024];   
3.           
4.     public static void main(String[] args) {  
5.         SoftRefTest objA = new SoftRefTest();  
6.         SoftReference<SoftRefTest> softRef = new SoftReference<SoftRefTest>(objA);  
7.         objA = null;  
8.         SoftRefTest objB = new SoftRefTest();  
9.         //System.gc();  
10.     }  
11. }  

     设置VM Arguments参数： 

Text代码  

1. -Xms3m -Xmx3m -XX:+PrintGCDetails -XX:+PrintGCDateStamps  

    运行该程序，通过控制台观察到软引用对象objA确实被回收了。

 

【关于finalize()方法】

    如果堆中的对象到GC Roots之间没有任何引用链，GC就可以对其进行回收. 在回收之前会调用对象的finalize()方法，可以通过覆盖该方法、把当前对象的引用重新和GC Roots连接起来、以阻止GC进行回收。 需要注意的是，一个对象的finalize()方法只会被执行一次、如果GC再次回收该对象，无法阻止被GC回收。

 

【永久代的垃圾回收】

    在Sun公司的HotSpot虚拟机中，方法区存放在Java堆的永久代(Permanent Generation)。在大量涉及反射、动态代理、cglib等字节码(bytecode)技术的场景(如项目中使用Spring、Hibernate等框架)，需要虚拟机具有类卸载的功能，保证永久代不会溢出。

 

【垃圾收集算法】

  1. 复制算法：Copying 

    将堆内存划分为两块，当其中一块正在使用中的的内存空间紧张时、把其中“存活”(仍然被引用)着的对象复制到另外一块空闲着的内存区域，然后清空当前内存空间. 复制算法通常作为新生代的垃圾回收策略。

  2. 标记-清除算法：Mark-Sweep

    先标记出可回收的对象，然后进行统一清除. 缺点：效率低、并且产生大量不连续的内存碎片。

  3. 标记-整理算法：Mark-Compact

    标记出可回收的对象、将所有存活的对象向其中一端移动，然后直接清理掉另一端的内存区域。

  4. 分代收集算法：Generational Collection

    将Java堆划分为新生代、老年代，新生代中的大多数对象都是可回收的，而老年代中的对象大多数都是不可回收的 。新生代采用复制算法：大多数对象都是可回收的、只需复制少数存活的对象、回收效率较高。老年代只有少数对象可回收、标记效率较高，因此采用标记-清除(无须移动对象)、标记-整理(移动存活对象到其中一侧)算法相结合进行回收。

 

【垃圾收集器】

  1. Serial收集器：串行收集器(collector)

    单线程的垃圾收集器，是JVM运行在client模式下的默认收集器，进行垃圾回收时、必须暂停其他所有的工作线程(Sun称之为“Stop The World”)。

  2. ParNew收集器：并行收集器

    Serial收集器的多线程版本、多条线程并行进行垃圾回收、以减少暂停时间，通常用于JVM在server模式下新生代的收集器。并行：(Parallel)：多个垃圾回收线程并行工作、仍需暂停其他工作线程。

  3. CMS收集器：Concurrent Mark Sweep

    并发标记清除收集器，通常作为老年代的收集器。并发(Concurrent)：多条垃圾回收线程和工作线程交替运行、无须暂停工作线程，最大程度的提高垃圾效率、减少工作线程的停顿时间。

 

【堆内存分配策略】

   1. 新创建的对象将存放在新生代的Eden(伊甸)区域、以及其中一个Survivor(存活者)区域(From Survivor)。

  2. 堆内存紧张时、进行新生代对象的回收，存活着的对象将从Eden和From Survivor区域复制到To Survivor区域，如果To Survivor区域内存紧张、一部分存活对象将直接复制到老年代存放，然后清空Eden和From Survivor区域.。在下一次新生代垃圾回收时、From Survivor和To Survivor区域的角色互换.

 3. 大对象(通常是指内容很长的字符串或者数组)直接放入老年代、以避免大对象在新生代的反复拷贝。

 4. (新生代中)长期存活的对象将放入老年代，新生代中的对象每在Survivor区域完成一次拷贝、该对象的

 年龄(Age)加1，当对象的年龄增加到一定值(默认为15)时、该对象将被存放到老年代，以避免该对象在

 新生代的反复拷贝。

 

【Minor/Major GC】

  新生代GC(Minor GC)：新生代的垃圾回收非常频繁(尽可能快的释放出可用空间)、效率很高(采用复制算法，大多数对象可回收、只需复制少数存活对象)。

  老年代GC(Major/Full GC)：老年代的垃圾回收、效率通常比新生代的Minor GC慢至少10倍，(采用标记-清除、标记-整理算法)，每次Full GC会同时进行至少一次Minor GC， 通常在堆内存紧张、或者显示的调用System.gc()时触发Full GC。

 

=================================

垃圾回收机制的学习，确实枯燥乏味，但这却是进行JVM参数调优的重要基础！