Java垃圾回收机制（2）

（一）GC的执行机制

　　由于对象进行了分代处理，因此垃圾回收区域、时间也不一样。GC有两种类型：Scavenge GC和Full GC。

Scavenge GC：

一般情况下，当新对象生成，并且在Eden申请空间失败时，就会触发Scavenge GC，对Eden区域进行GC，清除非存活对象，并且把尚且存活的对象移动到Survivor区。然后整理Survivor的两个区。这种方式的GC是对年轻代的Eden区进行，不会影响到年老代。因为大部分对象都是从Eden区开始的，同时Eden区不会分配的很大，所以Eden区的GC会频繁进行。因而，一般在这里需要使用速度快、效率高的算法，使Eden去能尽快空闲出来。

Full GC：

对整个堆进行整理，包括Young（年轻代）、Tenured（老年代）和Perm（持久代）。Full GC因为需要对整个堆进行回收，所以比Scavenge GC要慢，因此应该尽可能减少Full GC的次数。有如下原因可能导致Full GC：

　　1.年老代（Tenured）被写满

　　2.持久代（Perm）被写满

　　3.System.gc()被显示调用

　　4.上一次GC之后Heap堆的各域分配策略动态变化

（二）System.gc()方法
　　使用System.gc()可以不管JVM使用的是哪一种垃圾回收的算法，都可以请求Java的垃圾回收。在命令行中有一个参数-verbosegc可以查看Java使用的堆内存的情况，它的格式如下：
　　java -verbosegc classfile
　　可以看个例子：
class TestGC  
{  
    public static void main(String[] args)  
    {  
　　    new TestGC();  
　　    System.gc();  
　　    System.runFinalization();  
　　 }  
}  
      
　　在这个例子中，一个新的对象被创建，由于它没有使用，所以该对象迅速地变为不可达，程序编译后，执行命令： java -verbosegc TestGC 后结果为：
　　[Full GC 168K->97K(1984K)， 0.0253873 secs]
　　机器的环境为，Windows 2000 + JDK1.3.1，箭头前后的数据168K和97K分别表示垃圾收集GC前后所有存活对象使用的内存容量，说明有168K-97K=71K的对象容量被回收，括号内的数据1984K为堆内存的总容量，收集所需要的时间是0.0253873秒（这个时间在每次执行的时候会有所不同）。
      需要注意的是，调用System.gc()也仅仅是一个请求(建议)。JVM接受这个消息后，并不是立即做垃圾回收，而只是对几个垃圾回收算法做了加权，使垃圾回收操作容易发生，或提早发生，或回收较多而已。

（三）finalize()方法
      在JVM垃圾回收器收集一个对象之前，一般要求程序调用适当的方法释放资源，但在没有明确释放资源的情况下，Java提供了缺省机制来终止该对象心释放资源，这个方法就是finalize（）。一旦垃圾回收器准备好释放对象占用的存储空间，首先会去调用finalize()方法进行一些必要的清理工作。但是，只有到下一次再进行垃圾回收动作的时候，才会真正释放这个对象所占用的内存空间。
　　finalize原型为：protected void finalize() throws Throwable        原型中的throws Throwable表示它可以抛出任何类型的异常。
　　在finalize()方法返回之后，对象消失，垃圾收集开始执行。
　　之所以要使用finalize()，是存在着垃圾回收器不能处理的特殊情况。假定你的对象（并非使用new方法）获得了一块“特殊”的内存区域，由于垃圾回收器只知道那些显示地经由new分配的内存空间，所以它不知道该如何释放这块“特殊”的内存区域，那么这个时候java允许在类中定义一个由finalize()方法。
      特殊的区域例如：

1）由于在分配内存的时候可能采用了类似 C语言的做法，而非JAVA的通常new做法。这种情况主要发生在native method中，比如native method调用了C/C++方法malloc()函数系列来分配存储空间，但是除非调用free()函数，否则这些内存空间将不会得到释放，那么这个时候就可能造成内存泄漏。由于free()方法是在C/C++中的函数，所以finalize()中可以用本地方法来调用它。以释放这些“特殊”的内存空间。

2）又或者打开的文件资源，这些资源不属于垃圾回收器的回收范围。

3） 假设某一个对象在创建过程中会将自己绘制到屏幕上，如果不是明确地从屏幕上将其擦出，它可能永远都不会被清理。如果在finalize()加入某一种擦除功能，当GC工作时，finalize()得到了调用，图像就会被擦除。要是GC没有发生，那么这个图像就会被一直保存下来。
      注意：在C++中所有的对象运用delete()一定会被销毁，而JAVA里的对象并非总会被垃圾回收器回收。In another word, 1 对象可能不被垃圾回收，2 垃圾回收并不等于“析构”，3 垃圾回收只与内存有关。也就是说，并不是如果一个对象不再被使用，在finalize()中就会释放这个对象中含有的其它对象呢？不是的。因为垃圾回收器只会负责释放那些对象占有的内存，并不同析构一样，将这个对象包含的其他对象也全部析构掉。

（四）Java仍会出现内存泄漏的问题

1.静态集合类像HashMap、Vector等的使用最容易出现内存泄露，因为这些静态变量的生命周期和应用程序一致，他们所持有的对象Object也不能被释放，因为他们也将一直被Vector等应用着。

Static Vector v = new Vector(); 
for (int i = 1; i<100; i++) 
{ 
    Object o = new Object(); 
    v.add(o); 
    o = null; 
}

当 o 引用被置空后，如果发生 GC，我们创建的 Object 对象是否能够被 GC 回收呢？答案是否定的。因为尽管o 引用已经被置空，但是 Object 对象仍然存在其他的引用，是可以被访问到的，所以 GC 无法将其释放掉。在此循环之后， Object 对象对程序已经没有任何作用，那么我们就认为此 Java 程序发生了内存泄漏。

2.各种连接，数据库连接，网络连接，IO连接等没有显示调用close关闭，不被GC回收导致内存泄露。

3.监听器的使用，在释放对象的同时没有相应删除监听器的时候也可能导致内存泄露。

（五）减少GC开销的措施

　　(1)不要显式调用System.gc()

　　此函数建议JVM进行主GC,虽然只是建议而非一定,但很多情况下它会触发主GC,从而增加主GC的频率,也即增加了间歇性停顿的次数。

　　(2)尽量减少临时对象的使用

　　临时对象在跳出函数调用后,会成为垃圾,少用临时变量就相当于减少了垃圾的产生,从而延长了出现上述第二个触发条件出现的时间,减少了主GC的机会。

　　(3)对象不用时最好显式置为Null

　　一般而言,为Null的对象都会被作为垃圾处理,所以将不用的对象显式地设为Null,有利于GC收集器判定垃圾,从而提高了GC的效率。

　　(4)尽量使用StringBuffer,而不用String来累加字符串

　　由于String是固定长的字符串对象,累加String对象时,并非在一个String对象中扩增,而是重新创建新的String对象,如Str5=Str1+Str2+Str3+Str4,这条语句执行过程中会产生多个垃圾对象,因为对次作“+”操作时都必须创建新的String对象,但这些过渡对象对系统来说是没有实际意义的,只会增加更多的垃圾。避免这种情况可以改用StringBuffer来累加字符串,因StringBuffer是可变长的,它在原有基础上进行扩增,不会产生中间对象。

　　(5)能用基本类型如Int,Long,就不用Integer,Long对象

　　基本类型变量占用的内存资源比相应对象占用的少得多,如果没有必要,最好使用基本变量。

　　(6)尽量少用静态对象变量

　　静态变量属于全局变量,不会被GC回收,它们会一直占用内存。

　　(7)分散对象创建或删除的时间

　　集中在短时间内大量创建新对象,特别是大对象,会导致突然需要大量内存,JVM在面临这种情况时,只能进行主GC,以回收内存或整合内存碎片,从而增加主GC的频率。集中删除对象,道理也是一样的。它使得突然出现了大量的垃圾对象,空闲空间必然减少,从而大大增加了下一次创建新对象时强制主GC的机会。

      下面这个例子向大家展示了垃圾收集所经历的过程，并对前面的陈述进行了总结。

[java] view plain copy

1. class Chair {  
2. 　　static boolean gcrun = false;  
3. 　　static boolean f = false;  
4. 　　static int created = 0;  
5. 　　static int finalized = 0;  
6. 　　int i;  
7. 　　Chair() {  
8. 　　    i = ++created;  
9. 　　    if(created == 47)  
10. 　　　      System.out.println("Created 47");  
11. 　　}  
12. 　　protected void finalize() {  
13. 　　    if(!gcrun) {  
14. 　　　      gcrun = true;  
15. 　　　      System.out.println("Beginning to finalize after " + created + " Chairs have been created");  
16. 　　    }  
17. 　　    if(i == 47) {  
18. 　　　      System.out.println("Finalizing Chair #47， " +"Setting flag to stop Chair creation");  
19. 　　　      f = true;  
20. 　　    }  
21. 　　    finalized++;  
22. 　　    if(finalized >= created)  
23. 　　　      System.out.println("All " + finalized + " finalized");  
24. 　　}  
25. }  
26.   
27. public class Garbage {  
28. 　　public static void main(String[] args) {  
29. 　　if(args.length == 0) {  
30. 　　　  System.err.println("Usage: /n" + "java Garbage before/n or:/n" + "java Garbage after");  
31. 　　　  return;  
32. 　　}  
33. 　　while(!Chair.f) {  
34. 　　　  new Chair();  
35. 　　　  new String("To take up space");  
36. 　　}  
37. 　　System.out.println("After all Chairs have been created:/n" + "total created = " + Chair.created +  
38. 　　"， total finalized = " + Chair.finalized);  
39. 　　if(args[0].equals("before")) {  
40. 　　　　System.out.println("gc():");  
41. 　　　　System.gc();  
42. 　　　　System.out.println("runFinalization():");  
43. 　　　　System.runFinalization();  
44. 　　}  
45. 　　System.out.println("bye!");  
46. 　　if(args[0].equals("after"))  
47. 　　　  System.runFinalizersOnExit(true);  
48. 　　}  
49. }  

      上面这个程序创建了许多Chair对象，而且在垃圾收集器开始运行后的某些时候，程序会停止创建Chair。由于垃圾收集器可能在任何时间运行，所以我们不能准确知道它在何时启动。因此，程序用一个名为gcrun的标记来指出垃圾收集器是否已经开始运行。利用第二个标记f，Chair可告诉main()它应停止对象的生成。这两个标记都是在finalize()内部设置的，它调用于垃圾收集期间。另两个static变量--created以及 finalized--分别用于跟踪已创建的对象数量以及垃圾收集器已进行完收尾工作的对象数量。最后，每个Chair都有它自己的（非 static）int i，所以能跟踪了解它具体的编号是多少。编号为47的Chair进行完收尾工作后，标记会设为true，最终结束Chair对象的创建过程。