浅谈JVM垃圾回收之哪些对象可以被回收

1.背景

Java语言相比于C和C++，一个最大的特点就是不需要程序员自己手动去申请和释放内存，这一切交由JVM来完成。在Java中，运行时的数据区域分为程序计数器、Java虚拟机栈、本地方法栈、方法区和堆。其中，程序计数器、虚拟机栈和本地方法栈是线程私有的，线程销毁后自动释放。垃圾回收的行为发生在堆和方法区，主要是堆，而堆中存储的主要是对象。那么自然而然地就会有这么几个问题，哪些对象可以被回收？通过什么方式回收？本文主要探讨第一个问题，以及JVM对Java中几种引用的回收策略。

2.如何判断一个对象是否可以被回收

2.1 引用计数法

主要思想是：给对象添加一个引用计数器，这个对象被引用一次，计数器就加1；不再引用了，计数器就减1。如果一个对象的引用计数器为0，说明没有人使用这个对象，那么这个对象就可以被回收了。这种方法实现起来比较简单，效率也比较高，大多数情况下都是有效的。但是，这种方法有一个漏洞。比如A.property = B，B.property = A，A和B两个对象互相引用，并且没有其他对象引用A和B。按照引用计数法的思想，A和B对象的引用计数器都不为0，都不能被释放，但实际情况是A和B已经没人使用他们了，这就造成了内存泄漏。所以，引用计数法虽然实现简单，但并不是一个完美的解决方案，实际中的Java也没有采用它。

2.2 可达性分析算法

主要思想是：首先确定确定一系列肯定不能被回收的对象，即GC Roots。然后，从这些GC Roots出发，向下搜索，去寻找它直接和间接引用的对象。最后，如果一个对象没有被GC Roots直接或间接地引用，那么这个对象就可以被回收了。这种方法可以有效解决循环引用的问题，实际中Java也是采用这种判断方法。那么问题来了，哪些对象可以作为GC Roots呢？这里可以使用MAT工具进行观察。运行下面的demo：

import java.util.concurrent.TimeUnit;

public class GCRootsTest {
public static void main(String[] args) throws InterruptedException {
 Object o = new Object();
 TimeUnit.SECONDS.sleep(100);
}
}

主线程sleep的时候，在terminal窗口执行jmap -dump:format=b,live,file=heapdump.bin 2872命令，生成堆转储快照dump文件，其中2872是进程id，可以使用jps命令查看。然后使用MAT工具打开dump文件，可以很明显地看到一共有四类对象可以作为GC Roots，下面详细介绍下。

第一类，系统类对象（System Class）。比如，java.lang.String的Class对象，这个也很好理解，如果这些核心的系统类对象被回收了，程序就没办法运行了。

第二类，native方法引用的对象。

第三类，活动线程中正在引用的对象。可以看出，代码中变量o指向的Object对象可以被当作GC Roots。

第四类，正在加锁的对象。

3.Java中的几种引用

在可达性分析算法中，判断一个对象是不是可以被回收，主要看从GC Roots出发是否可以找到一个引用指向该对象。java中的引用一共有四种，按照引用的强弱依次为强引用（Strong Reference）、软引用（Soft Reference）、弱引用（Weak Reference）、虚引用（Phantom Reference）。这样就可以对不同引用指向的对象采取不同的回收策略。比如一个强引用指向一个对象，那么这个对象肯定不会被回收，哪怕发生OOM。而对于弱引用指向的对象，只要发生垃圾回收，该对象就会被回收。下面详细介绍下不同引用的用法。

3.1强引用

所谓强引用，就是平时使用最多的，类似于Object obj = new Object()的引用。垃圾回收器永远不会回收被强引用指向的对象。

3.2软引用

软引用，在Java中使用SoftReference类来实现软引用。在下面的代码中，softReference作为软用指向一个Object对象，而otherObject变量可以通过软引用的get方法间接引用到Object对象。

public static void main(String[] args) {
 // 软引用
 SoftReference<Object> softReference = new SoftReference<>(new Object());
 Object otherObject = softReference.get();
}

对于软引用指向的对象，当内存不够用时，该对象就会被回收。为演示这个现象，将JVM的堆内存设置为10M（-Xms10M -Xmx10M）。以下代码的主要逻辑是：向一个List集合中添加5个SoftReference对象，其中每个SoftReference对象都指向了一个大小为2M的byte数组，添加完成之后遍历List，并打印List中每一个软引用指向的对象。

public class ReferenceTest {

private static final int _2M = 2 * 1024 * 1024;

public static void main(String[] args) {
 List<SoftReference<Object>> list = new ArrayList<>();
 for (int i = 0; i < 5; i++) {
  SoftReference<Object> softReference = new SoftReference<>(new byte[_2M]);
  list.add(softReference);
 }

System.out.println("List集合中的软引用：");
 for (int i = 0; i < 5; i++) {
  System.out.println(list.get(i));
 }

System.out.println("--------------------------");
 System.out.println("List集合中的软引用指向的对象：");
 for (int i = 0; i < 5; i++) {
  System.out.println(list.get(i).get());
 }
}
}

上述代码在堆内存为10M的情况下运行的结果如下图。可以看到前三个软引用指向的对象已经被垃圾回收器回收掉了，原因就是堆内存不够用了，软引用指向的对象就被回收了。

通常情况下，软引用指向的对象被回收了，那么这个软引用也就没有存在的意义了，应该被垃圾回收器回收掉。为了实现这个效果，通常软引用要配合引用队列使用。用法如下面的代码所示，将软引用和引用队列关联，这样当软引用指向的对象被回收时，该软引用会自动加入到引用队列，这时候可以采用一定的策略将这些软引用对象回收。

public class ReferenceTest {

private static final int _2M = 2 * 1024 * 1024;

public static void main(String[] args) {
 List<SoftReference<Object>> list = new ArrayList<>();
 // 引用队列
 ReferenceQueue<Object> queue = new ReferenceQueue<>();
 for (int i = 0; i < 5; i++) {
  // 同时将软引用关联引用队列，当软引用指向的对象被回收时，该软引用会加入到队列
  SoftReference<Object> softReference = new SoftReference<>(new byte[_2M], queue);
  list.add(softReference);
 }

// 移除List中，指向对象已经被回收的软引用
 Reference<?> poll = queue.poll();
 while (null != poll) {
  list.remove(poll);
  poll = queue.poll();
 }

System.out.println("List集合中的软引用：");
 for (SoftReference<Object> reference : list) {
  System.out.println(reference);
 }

System.out.println("-------------------------------------");
 System.out.println("List集合中的软引用指向的对象：");
 for (SoftReference<Object> reference : list) {
  System.out.println(reference.get());
 }
}
}

执行结果如下：

3.3弱引用

弱引用，相比于软引用，它的引用程度更弱。只要发生垃圾回收，弱引用指向的对象都会被回收。话不多说，直接上代码。跟软引用的demo差不多，唯一不同的是每个byte的数组的大小变成了2K，这样堆肯定放的下，也不会发生垃圾回收。

public class WeakReferenceTest {
private static final int _2K = 2 * 1024;

public static void main(String[] args) {
 List<WeakReference<byte[]>> list = new ArrayList<>();
 for (int i = 0; i < 5; i++) {
  WeakReference<byte[]> reference = new WeakReference<>(new byte[_2K]);
  list.add(reference);
 }

System.out.println("List集合中的软引用：");
 for (WeakReference<byte[]> reference : list) {
  System.out.println(reference);
 }

System.out.println("-------------------------------------");
 System.out.println("List集合中的软引用指向的对象：");
 for (WeakReference<byte[]> reference: list) {
  System.out.println(reference.get());
 }
}
}

运行。可以看到弱引用指向的对象并没有被回收。

在上述代码的基础上，人为的进行一次垃圾回收，代码如下。

public class WeakReferenceTest {
private static final int _2K = 2 * 1024;

public static void main(String[] args) {
 List<WeakReference<byte[]>> list = new ArrayList<>();
 for (int i = 0; i < 5; i++) {
  WeakReference<byte[]> reference = new WeakReference<>(new byte[_2K]);
  list.add(reference);
 }

System.gc(); // 手动垃圾回收
 System.out.println("List集合中的弱引用：");
 for (WeakReference<byte[]> reference : list) {
  System.out.println(reference);
 }

System.out.println("-------------------------------------");
 System.out.println("List集合中的弱引用指向的对象：");
 for (WeakReference<byte[]> reference: list) {
  System.out.println(reference.get());
 }
}
}

运行。发现此时弱引用指向的对象都被回收掉了。和软引用一样，弱引用也可以结合引用队列使用，这里不再赘述。

3.4虚引用

与软引用和虚引用不同，虚引用必须配合引用队列使用，而且不能通过虚引用获取到虚引用指向的对象。在Java中虚引用使用PhantomReference类来表示，从PhantomReference的源码可以看出调用虚引用的get方法始终返回的是null，而且PhantomReference只提供了包含引用队列的有参构造器，这也就是说虚引用必须结合引用队列使用。

public class PhantomReference<T> extends Reference<T> {

public T get() {
 return null;
}

public PhantomReference(T referent, ReferenceQueue<? super T> q) {
 super(referent, q);
}

}

既然不能通过虚引用获取到它指向的对象，那么虚引用到底有什么用呢？实际上，为一个对象关联虚引用的唯一目的就是：在该对象被垃圾回收时收到一个系统通知。当垃圾回收器准备回收一个对象时，如果发现还有虚引用与之关联，就会在垃圾回收后，将这个虚引用加入引用队列，在其关联的虚引用出队前，不会彻底销毁该对象。 上面的描述还是不够通俗易懂，其实虚引用的一个经典的使用场景就是和DirectByteBuffer类关联使用。DirectByteBuffer类使用的是堆外内存（服务器内存中，除了JVM占用外的那部分），省去了数据到内核的拷贝，因此效率比ByteBuffer要高很多（这里的重点是虚引用，想要了解DirectByteBuffer类的底层原理，可以在网上找下资源），它的内存示意图如下。

虽然DirectByteBuffer类的效率很高，但是由于堆外内存JVM的垃圾回收器不能进行回收，所以要谨慎处理DirectByteBuffer类使用的堆外内存，否则极易造成服务器内存泄漏。为了解决这个问题，虚引用就派上用场了。DirectByteBuffer类的创建和回收主要分为以下几个步骤

创建DirecByteBuffer对象时会同时创建一个Cleaner虚引用对象，指向自己，同时传一个Deallocator对象给Cleaner

 Cleaner类的父类是PhantomReference，爷爷类是Reference。Reference类在初始化的时候会启动一个ReferenceHandler线程

当DirectByteBuffer对象被回收后，Cleaner对象会被加入引用队列

这时ReferenceHandler线程会调用Cleaner对象的clean方法完成对堆外内存的回收

clean方法会调用Deallocator的run方法，通过Unsafe类最终完成堆外内存的回收

总结起来就是一句话，用虚引用关联DirectByteBuffer对象，当DirectByteBuffer被回收后，虚引用对象会被加入到引用队列，进而由该虚引用对象完成对堆外内存的释放。（感兴趣的或伙伴可以跟以下DirectByteBuffer的源码）

4.总结

• JVM采用可达性分析算法来判断堆中有哪些对象可以被回收。

• 主要有四类对象可作为GC Roots：系统类对象、Native方法引用的对象、活动线程引用的对象以及正在加锁的对象。

• Java中常用的引用主要有四种，强引用、软引用、弱引用和虚引用，对不同引用指向的对象，JVM有不同的回收策略。

• 对于强引用指向的对象，垃圾回收器不会将其回收，即使是发生OOM。

• 对于软引用指向的对象，当内存不够时，垃圾回收器会将其回收。这个特点可以用来实现缓存，当内存不足时JVM会自动清理掉这些缓存。

• 对于弱引用指向的对象，当发生垃圾回收时，垃圾回收器会将其回收。

• 对于虚引用，必须配合引用队列使用，而且不能通过虚引用获取到虚引用指向的对象，为一个对象关联虚引用的唯一目的就是在该对象被垃圾回收时收到一个系统通知。
  

来源：https://blog.csdn.net/weixin_40988088/article/details/114769014