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:


  
  1. import java.util.concurrent.TimeUnit;
  2. public class GCRootsTest {
  3. public static void main(String[] args) throws InterruptedException {
  4. Object o = new Object();
  5. TimeUnit.SECONDS.sleep(100);
  6. }
  7. }

主线程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对象。


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

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


  
  1. public class ReferenceTest {
  2. private static final int _2M = 2 * 1024 * 1024;
  3. public static void main(String[] args) {
  4. List<SoftReference<Object>> list = new ArrayList<>();
  5. for (int i = 0; i < 5; i++) {
  6. SoftReference<Object> softReference = new SoftReference<>(new byte[_2M]);
  7. list.add(softReference);
  8. }
  9. System.out.println("List集合中的软引用:");
  10. for (int i = 0; i < 5; i++) {
  11. System.out.println(list.get(i));
  12. }
  13. System.out.println("--------------------------");
  14. System.out.println("List集合中的软引用指向的对象:");
  15. for (int i = 0; i < 5; i++) {
  16. System.out.println(list.get(i).get());
  17. }
  18. }
  19. }

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

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


  
  1. public class ReferenceTest {
  2. private static final int _2M = 2 * 1024 * 1024;
  3. public static void main(String[] args) {
  4. List<SoftReference<Object>> list = new ArrayList<>();
  5. // 引用队列
  6. ReferenceQueue<Object> queue = new ReferenceQueue<>();
  7. for (int i = 0; i < 5; i++) {
  8. // 同时将软引用关联引用队列,当软引用指向的对象被回收时,该软引用会加入到队列
  9. SoftReference<Object> softReference = new SoftReference<>(new byte[_2M], queue);
  10. list.add(softReference);
  11. }
  12. // 移除List中,指向对象已经被回收的软引用
  13. Reference<?> poll = queue.poll();
  14. while (null != poll) {
  15. list.remove(poll);
  16. poll = queue.poll();
  17. }
  18. System.out.println("List集合中的软引用:");
  19. for (SoftReference<Object> reference : list) {
  20. System.out.println(reference);
  21. }
  22. System.out.println("-------------------------------------");
  23. System.out.println("List集合中的软引用指向的对象:");
  24. for (SoftReference<Object> reference : list) {
  25. System.out.println(reference.get());
  26. }
  27. }
  28. }

执行结果如下:

3.3弱引用

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


  
  1. public class WeakReferenceTest {
  2. private static final int _2K = 2 * 1024;
  3. public static void main(String[] args) {
  4. List<WeakReference<byte[]>> list = new ArrayList<>();
  5. for (int i = 0; i < 5; i++) {
  6. WeakReference<byte[]> reference = new WeakReference<>(new byte[_2K]);
  7. list.add(reference);
  8. }
  9. System.out.println("List集合中的软引用:");
  10. for (WeakReference<byte[]> reference : list) {
  11. System.out.println(reference);
  12. }
  13. System.out.println("-------------------------------------");
  14. System.out.println("List集合中的软引用指向的对象:");
  15. for (WeakReference<byte[]> reference: list) {
  16. System.out.println(reference.get());
  17. }
  18. }
  19. }

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

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


  
  1. public class WeakReferenceTest {
  2. private static final int _2K = 2 * 1024;
  3. public static void main(String[] args) {
  4. List<WeakReference<byte[]>> list = new ArrayList<>();
  5. for (int i = 0; i < 5; i++) {
  6. WeakReference<byte[]> reference = new WeakReference<>(new byte[_2K]);
  7. list.add(reference);
  8. }
  9. System.gc(); // 手动垃圾回收
  10. System.out.println("List集合中的弱引用:");
  11. for (WeakReference<byte[]> reference : list) {
  12. System.out.println(reference);
  13. }
  14. System.out.println("-------------------------------------");
  15. System.out.println("List集合中的弱引用指向的对象:");
  16. for (WeakReference<byte[]> reference: list) {
  17. System.out.println(reference.get());
  18. }
  19. }
  20. }

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

3.4虚引用

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


  
  1. public class PhantomReference<T> extends Reference<T> {
  2. public T get() {
  3. return null;
  4. }
  5. public PhantomReference(T referent, ReferenceQueue<? super T> q) {
  6. super(referent, q);
  7. }
  8. }

既然不能通过虚引用获取到它指向的对象,那么虚引用到底有什么用呢?实际上,为一个对象关联虚引用的唯一目的就是:在​该对象被垃圾回收时收到一个系统通知。当垃圾回收器准备回收一个对象时,如果发现还有虚引用与之关联,就会在垃圾回收后,将这个虚引用加入引用队列,在其关联的虚引用出队前,不会彻底销毁该对象。 上面的描述还是不够通俗易懂,其实虚引用的一个经典的使用场景就是和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会自动清理掉这些缓存。
  • 对于弱引用指向的对象,当发生垃圾回收时,垃圾回收器会将其回收。
  • 对于虚引用,必须配合引用队列使用,而且不能通过虚引用获取到虚引用指向的对象,为一个对象关联虚引用的唯一目的就是在​该对象被垃圾回收时收到一个系统通知。

文章来源: blog.csdn.net,作者:一个上进的螺丝钉,版权归原作者所有,如需转载,请联系作者。

原文链接:blog.csdn.net/weixin_40988088/article/details/114769014

(完)