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

2024-04-02 19:04:59 672人浏览泡泡鱼

Python 官方文档：入门教程 => 点击学习

摘要

1.背景 Java语言相比于C和c++，一个最大的特点就是不需要程序员自己手动去申请和释放内存，这一切交由JVM来完成。在Java中，运行时的数据区域分为程序计数器、Java虚拟机栈

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类的底层原理，可以在网上找下资源），它的内存示意图如下。