jvm，深入理解java虚拟机，对象已死吗

在堆里面存放着Java世界中几乎所有的对象实例&＃xff0c;垃圾收集器在对堆进行回收前&＃xff0c;第一
件事情就是要确定这些对象之中哪些还“存活”着&＃xff0c;哪些已经“死去”&＃xff08;即不可能再被任何途径使用的对象&＃xff09;。

引用计数算法

很多教科书判断对象是否存活的算法是这样的&＃xff1a;给对象中添加一个引用计数器&＃xff0c;每当有
一个地方引用它时&＃xff0c;计数器值就加1&＃xff1b;当引用失效时&＃xff0c;计数器值就减1&＃xff1b;任何时刻计数器为0
的对象就是不可能再被使用的。作者面试过很多的应届生和一些有多年工作经验的开发人
员&＃xff0c;他们对于这个问题给予的都是这个答案。
客观地说&＃xff0c;引用计数算法&＃xff08;Reference  Counting&＃xff09;的实现简单&＃xff0c;判定效率也很高&＃xff0c;在大部
分情况下它都是一个不错的算法&＃xff0c;也有一些比较著名的应用案例&＃xff0c;例如微软公司的
COM&＃xff08;Component  Object Model&＃xff09;技术、使用ActionScript  3的FlashPlayer、Python语言和在游
戏脚本领域被广泛应用的Squirrel中都使用了引用计数算法进行内存管理。但是&＃xff0c;至少主流
的Java虚拟机里面没有选用引用计数算法来管理内存&＃xff0c;其中最主要的原因是它很难解决对象
之间相互循环引用的问题。
举个简单的例子&＃xff0c;请看代码清单3-1中的testGC&＃xff08;&＃xff09;方法&＃xff1a;对象objA和objB都有字段
instance&＃xff0c;赋值令objA.instance&＃61;objB及objB.instance&＃61;objA&＃xff0c;除此之外&＃xff0c;这两个对象再无任何引
用&＃xff0c;实际上这两个对象已经不可能再被访问&＃xff0c;但是它们因为互相引用着对方&＃xff0c;导致它们的引
用计数都不为0&＃xff0c;于是引用计数算法无法通知GC收集器回收它们。
代码清单3-1　引用计数算法的缺陷

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

运行结果&＃xff1a;
[F  u  l  l  G  C&＃xff08;S  y  s  t  e  m&＃xff09;[T  e  n  u  r  e  d&＃xff1a;0  K-&＃xff1e;2  1  0  K&＃xff08;1  0  2  4  0  K&＃xff09;&＃xff0c;0.0  1  4  9  1  4  2  s  e  c  s]4603K-&＃xff1e;210K&＃xff08;19456K&＃xff09;&＃xff0c;[Perm&＃xff1a;2999K-&＃xff1e; 2999K&＃xff08;21248K&＃xff09;]&＃xff0c;0.0150007 secs][Times&＃xff1a;user&＃61;0.01 sys&＃61;0.00&＃xff0c;real&＃61;0.02 secs]
Heap

def new generation total 9216K,used 82K[0x00000000055e0000&＃xff0c;0x0000000005fe0000&＃xff0c;0x0000000005fe0000&＃xff09; Eden space 8192K&＃xff0c;1%used[0x00000000055e0000&＃xff0c;0x00000000055f4850&＃xff0c;0x0000000005de0000&＃xff09; from space 1024K&＃xff0c;0%used[0x0000000005de0000&＃xff0c;0x0000000005de0000&＃xff0c;0x0000000005ee0000&＃xff09; to space 1024K&＃xff0c;0%used[0x0000000005ee0000&＃xff0c;0x0000000005ee0000&＃xff0c;0x0000000005fe0000&＃xff09; tenured generation total 10240K,used 210K[0x0000000005fe0000&＃xff0c;0x00000000069e0000&＃xff0c;0x00000000069e0000&＃xff09; the space 10240K&＃xff0c;2%used[0x0000000005fe0000&＃xff0c;0x0000000006014a18&＃xff0c;0x0000000006014c00&＃xff0c;0x00000000069e0000&＃xff09; compacting perm gen total 21248K,used 3016K[0x00000000069e0000&＃xff0c;0x0000000007ea0000&＃xff0c;0x000000000bde0000&＃xff09; the space 21248K&＃xff0c;14%used[0x00000000069e0000&＃xff0c;0x0000000006cd2398&＃xff0c;0x0000000006cd2400&＃xff0c;0x0000000007ea0000&＃xff09; No shared spaces configured.

从运行结果中可以清楚看到&＃xff0c;GC日志中包含“4603K-&＃xff1e;210K”&＃xff0c;意味着虚拟机并没有因

为这两个对象互相引用就不回收它们&＃xff0c;这也从侧面说明虚拟机并不是通过引用计数算法来判

断对象是否存活的。

可达性分析算法

在主流的商用程序语言&＃xff08;Java、C#&＃xff0c;甚至包括前面提到的古老的Lisp&＃xff09;的主流实现中&＃xff0c;
都是称通过可达性分析&＃xff08;Reachability  Analysis&＃xff09;来判定对象是否存活的。这个算法的基本思
路就是通过一系列的称为“GC  Roots”的对象作为起始点&＃xff0c;从这些节点开始向下搜索&＃xff0c;搜索所
走过的路径称为引用链&＃xff08;Reference  Chain&＃xff09;&＃xff0c;当一个对象到GC  Roots没有任何引用链相连
&＃xff08;用图论的话来说&＃xff0c;就是从GC  Roots到这个对象不可达&＃xff09;时&＃xff0c;则证明此对象是不可用的。如下
图所示&＃xff0c;对象object 5、object 6、object 7虽然互相有关联&＃xff0c;但是它们到GC Roots是不可达

的&＃xff0c;所以它们将会被判定为是可回收的对象。

在Java语言中&＃xff0c;可作为GC Roots的对象包括下面几种&＃xff1a;
虚拟机栈&＃xff08;栈帧中的本地变量表&＃xff09;中引用的对象。
方法区中类静态属性引用的对象。
方法区中常量引用的对象。

本地方法栈中JNI&＃xff08;即一般说的Native方法&＃xff09;引用的对象。

再谈引用

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

JDK 1.2之后&＃xff0c;提供了PhantomReference类来实现虚引用。

生存还是死亡

即使在可达性分析算法中不可达的对象&＃xff0c;也并非是“非死不可”的&＃xff0c;这时候它们暂时处
于“缓刑”阶段&＃xff0c;要真正宣告一个对象死亡&＃xff0c;至少要经历两次标记过程&＃xff1a;如果对象在进行可达
性分析后发现没有与GC  Roots相连接的引用链&＃xff0c;那它将会被第一次标记并且进行一次筛选&＃xff0c;
筛选的条件是此对象是否有必要执行finalize&＃xff08;&＃xff09;方法。当对象没有覆盖finalize&＃xff08;&＃xff09;方法&＃xff0c;或
者finalize&＃xff08;&＃xff09;方法已经被虚拟机调用过&＃xff0c;虚拟机将这两种情况都视为“没有必要执行”。
如果这个对象被判定为有必要执行finalize&＃xff08;&＃xff09;方法&＃xff0c;那么这个对象将会放置在一个叫做
F-Queue的队列之中&＃xff0c;并在稍后由一个由虚拟机自动建立的、低优先级的Finalizer线程去执行
它。这里所谓的“执行”是指虚拟机会触发这个方法&＃xff0c;但并不承诺会等待它运行结束&＃xff0c;这样做
的原因是&＃xff0c;如果一个对象在finalize&＃xff08;&＃xff09;方法中执行缓慢&＃xff0c;或者发生了死循环&＃xff08;更极端的情
况&＃xff09;&＃xff0c;将很可能会导致F-Queue队列中其他对象永久处于等待&＃xff0c;甚至导致整个内存回收系统
崩溃。finalize&＃xff08;&＃xff09;方法是对象逃脱死亡命运的最后一次机会&＃xff0c;稍后GC将对F-Queue中的对象
进行第二次小规模的标记&＃xff0c;如果对象要在finalize&＃xff08;&＃xff09;中成功拯救自己——只要重新与引用链
上的任何一个对象建立关联即可&＃xff0c;譬如把自己&＃xff08;this关键字&＃xff09;赋值给某个类变量或者对象的
成员变量&＃xff0c;那在第二次标记时它将被移除出“即将回收”的集合&＃xff1b;如果对象这时候还没有逃
脱&＃xff0c;那基本上它就真的被回收了。从代码清单3-2中我们可以看到一个对象的finalize&＃xff08;&＃xff09;被
执行&＃xff0c;但是它仍然可以存活。
代码清单3-2　一次对象自我拯救的演示

/*** 　一次对象自我拯救的演示*/
public class FinalizeEscapeGC {public static FinalizeEscapeGC SAVE_HOOK&＃61;null;public void isAlive(){System.out.println("yes,i am still alive&＃xff1a;&＃xff09;");}&＃64;Overrideprotected void finalize() throws Throwable {super.finalize();System.out.println("finalize mehtod executed&＃xff01;");FinalizeEscapeGC.SAVE_HOOK&＃61;this;}public static void main(String[] args) throws InterruptedException {SAVE_HOOK&＃61;new FinalizeEscapeGC();SAVE_HOOK&＃61;null;//对象第一次成功拯救自己System.gc();//因为finalize方法优先级很低&＃xff0c;所以暂停0.5秒以等待它Thread.sleep(500);if(SAVE_HOOK!&＃61;null){SAVE_HOOK.isAlive();}else{System.out.println("no,i am dead&＃xff1a;&＃xff08;");}//下面这段代码与上面的完全相同&＃xff0c;但是这次自救却失败了SAVE_HOOK&＃61;null;System.gc();//因为finalize方法优先级很低&＃xff0c;所以暂停0.5秒以等待它Thread.sleep(500);if(SAVE_HOOK!&＃61;null){SAVE_HOOK.isAlive();}else{System.out.println("no,i am dead&＃xff1a;&＃xff08;");}}
}

运行结果&＃xff1a;
finalize mehtod executed&＃xff01; yes,i am still alive&＃xff1a;&＃xff09; no,i am dead&＃xff1a;&＃xff08;
从代码清单3-2的运行结果可以看出&＃xff0c;SAVE_HOOK对象的finalize&＃xff08;&＃xff09;方法确实被GC收
集器触发过&＃xff0c;并且在被收集前成功逃脱了。另外一个值得注意的地方是&＃xff0c;代码中有两段完全一样的代码片段&＃xff0c;执行结果却是一次逃
脱成功&＃xff0c;一次失败&＃xff0c;这是因为任何一个对象的finalize&＃xff08;&＃xff09;方法都只会被系统自动调用一次&＃xff0c;
如果对象面临下一次回收&＃xff0c;它的finalize&＃xff08;&＃xff09;方法不会被再次执行&＃xff0c;因此第二段代码的自救行
动失败了。
需要特别说明的是&＃xff0c;上面关于对象死亡时finalize&＃xff08;&＃xff09;方法的描述可能带有悲情的艺术色
彩&＃xff0c;笔者并不鼓励大家使用这种方法来拯救对象。相反&＃xff0c;笔者建议大家尽量避免使用它&＃xff0c;因
为它不是C/C&＃43;&＃43;中的析构函数&＃xff0c;而是Java刚诞生时为了使C/C&＃43;&＃43;程序员更容易接受它所做出的
一个妥协。它的运行代价高昂&＃xff0c;不确定性大&＃xff0c;无法保证各个对象的调用顺序。有些教材中描
述它适合做“关闭外部资源”之类的工作&＃xff0c;这完全是对这个方法用途的一种自我安慰。
finalize&＃xff08;&＃xff09;能做的所有工作&＃xff0c;使用try-finally或者其他方式都可以做得更好、更及时&＃xff0c;所以笔

者建议大家完全可以忘掉Java语言中有这个方法的存在。

回收方法区

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