重新开始学习javase_对象的摧毁

一、概述（转：@深入理解Java虚拟机:JVM高级特性与最佳实践(最新第二版) )

经过半个世纪的发展，内存的动态分配与内存回收技术已经相当成熟，一切看起来都进入了“自动化”时代，那为什么我们还要去了解GC和内存分配呢？答案很简单：当需要排查各种内存溢出、内存泄漏问题时，当垃圾收集成为系统达到更高并发量的瓶颈时，我们就需要对这些“自动化”的技术实施必要的监控和调节。

Java内存运行时区域的各个部分，其中程序计数器、虚拟机栈、本地方法栈三个区域随线程而生，随线程而灭；栈中的栈帧随着方法的进入和退出而有条不紊地执行着出栈和入栈操作。每一个栈帧中分配多少内存基本上是在类结构确定下来时就已知的（尽管在运行期会由JIT编译器进行一些优化，但在本章基于概念模型的讨论中，大体上可以认为是编译期可知的），因此这几个区域的内存分配和回收都具备确定性，在这几个区域内不需要过多考虑回收的问题，因为方法结束或线程结束时，内存自然就跟随着回收了。而Java堆和方法区则不一样，一个接口中的多个实现类需要的内存可能不一样，一个方法中的多个分支需要的内存也可能不一样，我们只有在程序处于运行期间时才能知道会创建哪些对象，这部分内存的分配和回收都是动态的，垃圾收集器所关注的是这部分内存。

二、判断对象是否已死？

1. 引用计数算法
   很多教科书判断对象是否存活的算法是这样的：给对象中添加一个引用计数器，每当有一个地方引用它时，计数器值就加1；当引用失效时，计数器值就减1；任何时刻计数器都为0的对象就是不可能再被使用的引用计数算法（Reference Counting）的实现简单，判定效率也很高，在大部分情况下它都是一个不错的算法，也有一些比较著名的应用案例，例如微软的COM（Component Object Model）技术、使用ActionScript 3的FlashPlayer、Python语言以及在游戏脚本领域中被广泛应用的Squirrel中都使用了引用计数算法进行内存管理。但是，Java语言中没有选用引用计数算法来管理内存，其中最主要的原因是它很难解决对象之间的相互循环引用的问题。 
   举个简单的例子，请看代码清单3-1中的testGC()方法：对象objA和objB都有字段instance，赋值令objA.instance = objB及objB.instance = objA，除此之外，这两个对象再无任何引用，实际上这两个对象已经不可能再被访问，但是它们因为互相引用着对方，导致它们的引用计数都不为0，于是引用计数算法无法通知GC收集器回收它们。 
   代码清单3-1　引用计数算法的缺陷

   /**
   * testGC()方法执行后，objA和objB会不会被GC呢？
   * @author zzm
   */
   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();
   　　}
   }

   

   运行结果： 
   [Full GC (System) [Tenured: 0K->210K(10240K), 0.0149142 secs] 4603K->210K(19456K), [Perm : 2999K->2999K(21248K)], 0.0150007 secs] [Times: user=0.01 sys=0.00, real=0.02 secs] 
   Heap 
   def new generation   total 9216K, used 82K [0x00000000055e0000, 0x0000000005fe0000, 0x0000000005fe0000) 
     Eden space 8192K,   1% used [0x00000000055e0000, 0x00000000055f4850, 0x0000000005de0000) 
     from space 1024K,   0% used [0x0000000005de0000, 0x0000000005de0000, 0x0000000005ee0000) 
     to   space 1024K,   0% used [0x0000000005ee0000, 0x0000000005ee0000, 0x0000000005fe0000) 
   tenured generation   total 10240K, used 210K [0x0000000005fe0000, 0x00000000069e0000, 0x00000000069e0000) 
      the space 10240K,   2% used [0x0000000005fe0000, 0x0000000006014a18, 0x0000000006014c00, 0x00000000069e0000) 
   compacting perm gen  total 21248K, used 3016K [0x00000000069e0000, 0x0000000007ea0000, 0x000000000bde0000) 
      the space 21248K,  14% used [0x00000000069e0000, 0x0000000006cd2398, 0x0000000006cd2400, 0x0000000007ea0000) 
   No shared spaces configured. 
          从运行结果中可以清楚地看到GC日志中包含“4603K->210K”，意味着虚拟机并没有因为这两个对象互相引用就不回收它们，这也从侧面说明虚拟机并不是通过引用计数算法来判断对象是否存活的。

2. 根搜索算法：
   在主流的商用程序语言中（Java和C#，甚至包括前面提到的古老的Lisp），都是使用根搜索算法（GC Roots Tracing）判定对象是否存活的。这个算法的基本思路就是通过一系列的名为“GC Roots”的对象作为起始点，从这些节点开始向下搜索，搜索所走过的路径称为引用链（Reference Chain），当一个对象到GC Roots没有任何引用链相连（用图论的话来说就是从GC Roots到这个对象不可达）时，则证明此对象是不可用的。如图3-1所示，对象object 5、object 6、object 7虽然互相有关联，但是它们到GC Roots是不可达的，所以它们将会被判定为是可回收的对象。 
   在Java语言里，可作为GC Roots的对象包括下面几种： 
   虚拟机栈（栈帧中的本地变量表）中的引用的对象。 
   方法区中的类静态属性引用的对象。 
   方法区中的常量引用的对象。 
   本地方法栈中JNI（即一般说的Native方法）的引用的对象。
   
   在根搜索算法中不可达的对象，也并非是“非死不可”的，这时候它们暂时处于“缓刑”阶段，要真正宣告一个对象死亡，至少要经历两次标记过程：如果对象在进行根搜索后发现没有与GC Roots相连接的引用链，那它将会被第一次标记并且进行一次筛选，筛选的条件是此对象是否有必要执行finalize()方法。当对象没有覆盖finalize()方法，或者finalize()方法已经被虚拟机调用过，虚拟机将这两种情况都视为“没有必要执行”。 
   如果这个对象被判定为有必要执行finalize()方法，那么这个对象将会被放置在一个名为F-Queue的队列之中，并在稍后由一条由虚拟机自动建立的、低优先级的Finalizer线程去执行。这里所谓的“执行”是指虚拟机会触发这个方法，但并不承诺会等待它运行结束。这样做的原因是，如果一个对象在finalize()方法中执行缓慢，或者发生了死循环（更极端的情况），将很可能会导致F-Queue队列中的其他对象永久处于等待状态，甚至导致整个内存回收系统崩溃。finalize()方法是对象逃脱死亡命运的最后一次机会，稍后GC将对F-Queue中的对象进行第二次小规模的标记，如果对象要在finalize()中成功拯救自己—只要重新与引用链上的任何一个对象建立关联即可，譬如把自己（this关键字）赋值给某个类变量或对象的成员变量，那在第二次标记时它将被移除出“即将回收”的集合；如果对象这时候还没有逃脱，那它就真的离死不远了。从代码清单3-2中我们可以看到一个对象的finalize()被执行，但是它仍然可以存活。 
   从代码清单3-2的运行结果可以看到，SAVE_HOOK对象的finalize()方法确实被GC收集器触发过，并且在被收集前成功逃脱了。

   代码清单3-2　一次对象自我拯救的演示
   /**
   * 此代码演示了两点：
   * 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[img]/images/smiles/icon_smile.gif" alt="[/img]");
   　　} 
   
   　　@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();
   　　　// 因为Finalizer方法优先级很低，暂停0.5秒，以等待它
   　　　Thread.sleep(500);
   　　　if (SAVE_HOOK != null) {
   　　　SAVE_HOOK.isAlive();
   　　　} else {
   　　　System.out.println("no, i am dead[img]/images/smiles/icon_sad.gif" alt="[/img]");
   　　　} 
   
   　　　// 下面这段代码与上面的完全相同，但是这次自救却失败了
   　　　SAVE_HOOK = null;
   　　　System.gc();
   　　　// 因为Finalizer方法优先级很低，暂停0.5秒，以等待它
   　　　Thread.sleep(500);
   　　　if (SAVE_HOOK != null) {
   　　　SAVE_HOOK.isAlive();
   　　　} else {
   　　　System.out.println("no, i am dead[img]/images/smiles/icon_sad.gif" alt="[/img]");
   　　　}
   　　}
   }
   运行结果：
   finalize mehtod executed!
   yes, i am still alive[img]/images/smiles/icon_smile.gif" alt="[/img]
   no, i am dead[img]/images/smiles/icon_sad.gif" alt="[/img] 

   另外一个值得注意的地方就是，代码中有两段完全一样的代码片段，执行结果却是一次逃脱成功，一次失败，这是因为任何一个对象的finalize()方法都只会被系统自动调用一次，如果对象面临下一次回收，它的finalize()方法不会被再次执行，因此第二段代码的自救行动失败了。 
   需要特别说明的是，上面关于对象死亡时finalize()方法的描述可能带有悲情的艺术色彩，笔者并不鼓励大家使用这种方法来拯救对象。相反，笔者建议大家尽量避免使用它，因为它不是C/C++中的析构函数，而是Java刚诞生时为了使C/C++程序员更容易接受它所做出的一个妥协。它的运行代价高昂，不确定性大，无法保证各个对象的调用顺序。有些教材中提到它适合做“关闭外部资源”之类的工作，这完全是对这种方法的用途的一种自我安慰。finalize()能做的所有工作，使用try-finally或其他方式都可以做得更好、更及时，大家完全可以忘掉Java语言中还有这个方法的存在。

3. 回收方法区
   很多人认为方法区（或者HotSpot虚拟机中的永久代）是没有垃圾收集的，Java虚拟机规范中确实说过可以不要求虚拟机在方法区实现垃圾收集，而且在方法区进行垃圾收集的“性价比”一般比较低：在堆中，尤其是在新生代中，常规应用进行一次垃圾收集一般可以回收70%~95%的空间，而永久代的垃圾收集效率远低于此。 
   永久代的垃圾收集主要回收两部分内容：废弃常量和无用的类。回收废弃常量与回收Java堆中的对象非常类似。以常量池中字面量的回收为例，假如一个字符串“abc”已经进入了常量池中，但是当前系统没有任何一个String对象是叫做“abc”的，换句话说是没有任何String对象引用常量池中的“abc”常量，也没有其他地方引用了这个字面量，如果在这时候发生内存回收，而且必要的话，这个“abc”常量就会被系统“请”出常量池。常量池中的其他类（接口）、方法、字段的符号引用也与此类似。 
   判定一个常量是否是“废弃常量”比较简单，而要判定一个类是否是“无用的类”的条件则相对苛刻许多。类需要同时满足下面3个条件才能算是“无用的类”： 
         该类所有的实例都已经被回收，也就是Java堆中不存在该类的任何实例。 
         加载该类的ClassLoader已经被回收。 
         该类对应的java.lang.Class 对象没有在任何地方被引用，无法在任何地方通过反射访问该类的方法。 
   虚拟机可以对满足上述3个条件的无用类进行回收，这里说的仅仅是“可以”，而不是和对象一样，不使用了就必然会回收。是否对类进行回收，HotSpot虚拟机提供了-Xnoclassgc参数进行控制，还可以使用-verbose:class及-XX:+TraceClassLoading、 -XX:+TraceClassUnLoading查看类的加载和卸载信息。 
   在大量使用反射、动态代理、CGLib等bytecode框架的场景，以及动态生成JSP和OSGi这类频繁自定义ClassLoader的场景都需要虚拟机具备类卸载的功能，以保证永久代不会溢出。