Java 垃圾回收 - 对象引用

在 JDK 1.2 之前，Java 对象的引用很传统：如果 reference 类型的数据中存储的数值代表的是另外一块内存的起始地址，就称这块内存代表着一个引用。这种定义很纯粹，但是太过狭隘，一个对象在这种状态下只有被引用或不被引用两种状态，有时候我们希望描述这样一类对象：当内存空间还足够时，则能保留在内存之中；如果内存空间在进行垃圾收集后还是非常紧张，则可以抛弃这些对象。

为了方便测试，我们先定义一个占有 5M 内存的大对象 BigObj.java ,代码如下：

public class BigObj {
  /* 初始化一个 byte 数组，占 5M 内存 */
  private byte[] bigSize = new byte[5 * 1024 * 1024];
}

另外写一个工具类 RefUtil.java 统计一个引用类型的 List 中所有引用不为 null 的元素索引：

import java.lang.ref.Reference;
import java.util.ArrayList;
import java.util.List;

public class RefUtil {
  private RefUtil() {
  }

  public static <T> List<Integer> getNotNullIndexList(List<? extends Reference<T>> list) {
    List<Integer> indexList = new ArrayList<>();
    if (list != null) {
      for (int index = 0; index < list.size(); index++) {
        Reference<T> ref = list.get(index);
        T t = ref.get();
        if (t != null) {
          indexList.add(index);
        }
      }
    }
    return indexList;
  }
}

在 JDK 1.2 之后，Java 对引用的概念就行了扩充，将引用分为以下 4 中类型，且其引用强度依次逐渐减弱：

1. 强引用（ Strong Reference ）

强引用就是指在程序代码之中普遍存在的引用，类似 Object obj = new Object ( ) ，只要强引用还存在，垃圾收集器永远不会回收掉被引用的对象。

我们写一段简单的代码，验证强引用的垃圾收集：

StrongRef.java

import java.util.ArrayList;
import java.util.List;

public class StrongRef {
  public static void main(String[] args) {
    List<BigObj> list = new ArrayList<>();
    for (int i = 0; ; i++) {
      list.add(new BigObj());
      System.out.println("add BigObj,i=" + i + ",list.size=" + list.size());
    }
  }
}

编译后使用命令 java -XX:+PrintGC -Xmx20m StrongRef 运行上述代码，看到控制台输出：

add BigObj,i=0,list.size=1
add BigObj,i=1,list.size=2
[GC (Allocation Failure)  10843K->10728K(19968K), 0.0039335 secs]
add BigObj,i=2,list.size=3
[GC (Allocation Failure) -- 15960K->15960K(19968K), 0.0009668 secs]
[Full GC (Ergonomics)  15960K->15669K(19968K), 0.0047110 secs]
[GC (Allocation Failure) -- 15669K->15669K(19968K), 0.0008217 secs]
[Full GC (Allocation Failure)  15669K->15657K(19968K), 0.0036429 secs]
Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
    at BigObj.<init>(BigObj.java:3)
    at StrongRef.main(StrongRef.java:11)
[GC (Allocation Failure)  15872K->10664K(19968K), 0.0006627 secs]

由此可见，List 中的 BigObj 一直未被回收导致了 OutOfMemoryError 。

2. 软引用（ Soft Reference ）

软引用用来描述一些还有用但并非必需的对象。对于软引用关联着的对象，在系统将要发生内存溢出异常之前，将会把这些对象列进回收范围之中进行第二次回收。如果这次回收还没有足够的内存，才会抛出内存溢出异常。使用 java -XX:+PrintGC -Xmx20m SoftRef 运行下面程序：

SoftRef.java

import java.lang.ref.SoftReference;
import java.util.ArrayList;
import java.util.List;

public class SoftRef {
  public static void main(String[] args) {
    List<SoftReference<BigObj>> list = new ArrayList<>();
    for (int i = 0; ; i++) {
      SoftReference<BigObj> softRef = new SoftReference<>(new BigObj());
      list.add(softRef);

      List<Integer> indexList = RefUtil.getNotNullIndexList(list);
      System.out.println("i=" + i + ",before gc,not null index list is :" + indexList);
      System.gc();
      indexList = RefUtil.getNotNullIndexList(list);
      System.out.println("i=" + i + ",after gc,not null index list is :" + indexList);

    }
  }
}

控制台输出：

i=0,before gc,not null index list is :[0]
[GC (System.gc())  5723K->5608K(19968K), 0.0014306 secs]
[Full GC (System.gc())  5608K->5432K(19968K), 0.0039585 secs]
i=0,after gc,not null index list is :[0]
i=1,before gc,not null index list is :[0, 1]
[GC (System.gc())  10665K->10648K(19968K), 0.0021876 secs]
[Full GC (System.gc())  10648K->10550K(19968K), 0.0047034 secs]
i=1,after gc,not null index list is :[0, 1]
i=2,before gc,not null index list is :[0, 1, 2]
[Full GC (System.gc())  15894K->15665K(19968K), 0.0044271 secs]
i=2,after gc,not null index list is :[0, 1, 2]
[Full GC (Ergonomics)  15776K->15665K(19968K), 0.0025020 secs]
[Full GC (Allocation Failure)  15665K->293K(19968K), 0.0036120 secs]
i=3,before gc,not null index list is :[3]
[GC (System.gc())  5485K->5477K(19968K), 0.0009540 secs]
[Full GC (System.gc())  5477K->5413K(19968K), 0.0018795 secs]
i=3,after gc,not null index list is :[3]
i=4,before gc,not null index list is :[3, 4]
[GC (System.gc())  10619K->10597K(19968K), 0.0012132 secs]
[Full GC (System.gc())  10597K->10533K(19968K), 0.0022617 secs]
i=4,after gc,not null index list is :[3, 4]
i=5,before gc,not null index list is :[3, 4, 5]
[Full GC (System.gc())  15748K->15653K(19968K), 0.0022539 secs]
i=5,after gc,not null index list is :[3, 4, 5]
[Full GC (Ergonomics)  15754K->15653K(19968K), 0.0025003 secs]
[Full GC (Allocation Failure)  15653K->293K(19968K), 0.0033298 secs]
i=6,before gc,not null index list is :[6]
[GC (System.gc())  5478K->5477K(19968K), 0.0008587 secs]
[Full GC (System.gc())  5477K->5413K(19968K), 0.0020522 secs]
i=6,after gc,not null index list is :[6]
...

通过控制台输出可以看出，在前 3 次（i=0,1,2）往 List 中添加元素时，虚拟机垃圾回收并没有将软引用回收；在第 4 次添加时，由于内存不够，前面添加进去的已经被回收了，这也验证了软引用是在内存不足时回收的。

3. 弱引用（ Weak Reference ）

弱引用也是用来描述非必需对象的，但是它的强度比软引用更弱一些，被弱引用关联的对象只能生存到下一次垃圾回收之前。当垃圾收集器工作时，无论当前内存是否足够，都会回收掉只被弱引用关联的对象。如下代码所示：

WeakRef.java

import java.lang.ref.WeakReference;
import java.util.ArrayList;
import java.util.List;

public class WeakRef {
  public static void main(String[] args) {
    List<WeakReference<BigObj>> list = new ArrayList<>();
    for (int i = 0; ; i++) {
      WeakReference<BigObj> softRef = new WeakReference<>(new BigObj());
      list.add(softRef);

      List<Integer> indexList = RefUtil.getNotNullIndexList(list);
      System.out.println("i=" + i + ",before gc,not null index list is :" + indexList);
      System.gc();
      indexList = RefUtil.getNotNullIndexList(list);
      System.out.println("i=" + i + ",after gc,not null index list is :" + indexList);

    }
  }
}

使用 java -XX:+PrintGC -Xmx20m WeakRef 运行控制台输出：

i=0,before gc,not null index list is :[0]
[GC (System.gc())  5723K->5592K(19968K), 0.0014569 secs]
[Full GC (System.gc())  5592K->312K(19968K), 0.0041624 secs]
i=0,after gc,not null index list is :[]
i=1,before gc,not null index list is :[1]
[GC (System.gc())  5545K->376K(19968K), 0.0005063 secs]
[Full GC (System.gc())  376K->310K(19968K), 0.0035314 secs]
i=1,after gc,not null index list is :[]
i=2,before gc,not null index list is :[2]
[GC (System.gc())  5654K->342K(19968K), 0.0003902 secs]
[Full GC (System.gc())  342K->305K(19968K), 0.0036339 secs]
i=2,after gc,not null index list is :[]
i=3,before gc,not null index list is :[3]
[GC (System.gc())  5536K->369K(19968K), 0.0004402 secs]
[Full GC (System.gc())  369K->305K(19968K), 0.0036465 secs]
i=3,after gc,not null index list is :[]
...

通过控制台输出可以看出,每次垃圾回收都将 List 中的元素回收了，虚拟机并不会因为内存充足而不回收弱引用。

4. 虚引用（ Phantom Reference ）

虚引用也称为幽灵引用或者幻影引用，它是最弱的一种引用关系。一个对象是否有虚引用的存在，完全不会对其生存时间构成影响，也无法通过虚引用来取得一个对象的实例。查看 JDK 中 PhantomReference.java 的源码你会发现，其 get( ) 方法直接返回了 null 。

public class PhantomReference<T> extends Reference<T> {
   // 其他方法和属性
    public T get() {
        return null;
    }
}    

为一个对象设置虚引用关联的唯一目的就是能在这个对象被回收时收到一个系统通知。如下测试代码：

PhantomRef.java

import java.lang.ref.PhantomReference;
import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;
import java.lang.reflect.Field;
import java.util.concurrent.Executors;

public class PhantomRef {
  public static void main(String[] args) {

    final ReferenceQueue<BigObj> referenceQueue = new ReferenceQueue<>();
    Runnable runnable = () -> {
      while (true) {
        Reference<? extends BigObj> reference = referenceQueue.poll();
        if (reference == null) {
          continue;
        }
        try {
          Field rereferent = Reference.class.getDeclaredField("referent");
          rereferent.setAccessible(true);
          Object obj = rereferent.get(reference);
          System.out.println("gc will collect BigObj instance : " + obj.getClass() + "@" + obj.hashCode());
        } catch (NoSuchFieldException e) {
          e.printStackTrace();
        } catch (IllegalAccessException e) {
          e.printStackTrace();
        }
      }
    };
    Executors.newSingleThreadExecutor().execute(runnable);
    
    BigObj bigObj = new BigObj();
    System.out.println("new BigObj instance is : " + bigObj.getClass() + "@" + bigObj.hashCode());
    PhantomReference<BigObj> phantomReference = new PhantomReference<>(bigObj, referenceQueue);//这里一定要把 new 的对象赋值给一个变量
    bigObj = null;
    System.gc();
    System.out.println("---------------------gc 1 ------------------");
    bigObj = new BigObj();
    System.out.println("new BigObj instance is : " + bigObj.getClass() + "@" + bigObj.hashCode());
    phantomReference = new PhantomReference<>(bigObj, referenceQueue);//这里一定要把 new 的对象赋值给一个变量
    bigObj = null;
    System.gc();
    System.out.println("---------------------gc 2 ------------------");
  }
}

直接运行上述代码控制台输出：

new BigObj instance is : class BigObj@1044036744
---------------------gc 1 ------------------
gc will collect BigObj instance : class BigObj@1044036744
new BigObj instance is : class BigObj@1826771953
---------------------gc 2 ------------------
gc will collect BigObj instance : class BigObj@1826771953

说明

文章摘自《深入理解Java虚拟机》第二版 周志明著，仅作为学习记录，书籍中用到的案例代码及描述有部分修改，但未改变原意。