跟面试官聊到JVM，他通常会跟你谈谈这个问题？

前言：

但凡问到 JVM（Java 虚拟机）一般有 99% 的几率必定会问：在 JVM 中如何判断一个对象的生死状态？

本文就来聊聊这个问题，判断对象的生死状态的算法有如下几个：

一、引用计数器算法

引用计算器判断对象是否存活的算法是这样的：给每个对象设置一个引用计数器，每当有一个地方引用这个对象的时候，计数器就加1，与之相反，每当引用失效的时候就减1。

优势：实现简单、性能高。

缺点：增减处理频繁消耗cpu计算、计数器占用不少位浪费空间、最重要的缺点是没法解决循环引用的问题。

由于引用计数器算法很难解决循环引用的问题，因此主流的Java虚拟机都没有使用引用计数器算法来管理内存。

public class ReferenceDemo {
 public Object instance = null;
 private static final int _1Mb = 1024 * 1024;
 private byte [] bigSize = new byte[10 * _1Mb]; // 申请内存
 public static void main(String [] args) {
 System.out.println(String.format("开始：%d M",Runtime.getRuntime().freeMemory() / (1024 * 1024)));
 ReferenceDemo referenceDemo = new ReferenceDemo ();
 ReferenceDemo referenceDemo2 = new ReferenceDemo ();
 referenceDemo.instance = referenceDemo2;
 referenceDemo2.instance = referenceDemo;
 System.out.println(String.format("运行：%d M",Runtime.getRuntime().freeMemory() / (1024 * 1024)));
 referenceDemo = null;
 referenceDemo2 = null;
 System.gc(); // 手动触发垃圾回收
 System.out.println(String.format("结束：%d M",Runtime.getRuntime().freeMemory() / (1024 * 1024)));
 }
}
复制代码

运行的结果：

开始：117 M
运行中：96 M
结束：119 M

从结果能够看出，虚拟机并无由于相互引用就不回收它们，也侧面说明了虚拟机并非使用引用计数器实现的。

二、可达性分析算法

在主流的语言的主流实现中，好比Java、C#、甚至是古老的Lisp都是使用的可达性分析算法来判断对象是否存活的。

这个算法的核心思路就是经过一些列的“GC Roots”对象做为起始点，从这些对象开始往下搜索，搜索所通过的路径称之为“引用链”。

当一个对象到GC Roots没有任何引用链相连的时候，证实此对象是能够被回收的。以下图所示：

image

在Java中，可做为GC Roots对象的列表：

• Java虚拟机栈中的引用对象。
• 本地方法栈中JNI（既通常说的Native方法）引用的对象。
• 方法区中类静态常量的引用对象。
• 方法区中常量的引用对象。

对象生死与引用的关系

从上面的两种算法来看，不论是引用计数法仍是可达性分析算法都与对象的“引用”有关，这说明：对象的引用决定了对象的生死。

那对象的引用都有那些呢？

在JDK1.2以前，引用的定义很传统：若是reference类型的数据中存储的数值表明的是另外一块内存的起始地址，就称这块内存表明着一块引用。

这样的定义很纯粹，可是也很狭隘，这种状况下一个对象要么被引用，要么没引用，对于介于二者之间的对象显得无能为力。

JDK1.2以后对引用进行了扩充，将引用分为：

• 强引用（Strong Reference）
• 软引用（Soft Reference）
• 弱引用（Weak Reference）
• 虚引用（Phantom Reference）

这也就是文章开头第一个问题的答案，对象不是非生即死的，当空间还足够时，还能够保留这些对象

若是空间不足时，再抛弃这些对象。不少缓存功能的实现也符合这样的场景。

强引用、软引用、弱引用、虚引用，这4种引用的强度是依次递减的。

强引用：在代码中广泛存在的，相似“Object obj = new Object()”这类引用，只要强引用还在，垃圾收集器永远不会回收掉被引用的对象。

软引用：是一种相对强引用弱化一些的引用，可让对象豁免一些垃圾收集，只有当jvm认为内存不足时，才会去试图回收软引用指向的对象。jvm会确保在抛出OutOfMemoryError以前，清理软引用指向的对象。

弱引用：非必需对象，但它的强度比软引用更弱，被弱引用关联的对象只能生存到下一次垃圾收集发生以前。

虚引用：也称为幽灵引用或幻影引用，是最弱的一种引用关系，没法经过虚引用来获取一个对象实例，为对象设置虚引用的目的只有一个，就是当着个对象被收集器回收时收到一条系统通知。

死亡标记与拯救

在可达性算法中不可达的对象，并非“非死不可”的，要真正宣告一个对象死亡，至少要经历两次标记的过程。

若是对象在进行可达性分析以后，没有与GC Roots相链接的引用链，它会被第一次标记，并进行筛选，筛选的条件是此对象是否有必要执行finalize()方法。

执行finalize()方法的两个条件：

一、重写了finalize()方法。

二、finalize()方法以前没被调用过，由于对象的finalize()方法只能被执行一次。

若是知足以上两个条件，这个对象将会放置在F-Queue的队列之中，并在稍后由一个虚拟机自建的、低优先级Finalizer线程来执行它。

对象的“自我拯救”

finalize()方法是对象脱离死亡命运最后的机会，若是对象在finalize()方法中从新与引用链上的任何一个对象创建关联便可，好比把本身（this关键字）赋值给某个类变量或对象的成员变量。

来看具体的实现代码：

public class FinalizeDemo {
 public static FinalizeDemo Hook = null;
 @Override
 protected void finalize() throws Throwable {
 super.finalize();
 System.out.println("执行finalize方法");
 FinalizeDemo.Hook = this;
 }
 public static void main(String[] args) throws InterruptedException { 
 Hook = new FinalizeDemo();
 // 第一次拯救
 Hook = null;
 System.gc();
 Thread.sleep(500); // 等待finalize执行
 if (Hook != null) {
 System.out.println("我还活着");
 } else {
 System.out.println("我已经死了");
 }
 // 第二次，代码彻底同样
 Hook = null;
 System.gc();
 Thread.sleep(500); // 等待finalize执行
 if (Hook != null) {
 System.out.println("我还活着");
 } else {
 System.out.println("我已经死了");
 }
 }
}
复制代码

执行的结果：

执行finalize方法
我还活着
我已经死了

从结果能够看出，任何对象的finalize()方法都只会被系统调用一次。

不建议使用finalize()方法来拯救对象，缘由以下：

一、对象的finalize()只能执行一次。

二、它的运行代价高昂。

三、不肯定性大。

四、没法保证各个对象的调用顺序。

关注做者，我的主页有福利哦！