Java 对象四种引用类型

在 Java 的对象世界里面，对象的引用有 4 类之分，分别是：强引用（Strong Reference）、软引用（Soft Reference）、弱引用（Weak Reference）和虚引用（Phantom Reference）。

强引用（Strong Reference）

在使用new操作符创建的对象，在对象的生命周期内，GC 是不会回收该对象的，除非主动释放该对象（将引用设置为 null），否则 JVM 宁可抛出 OOM 异常，也不会将具有强引用的对象回收。

如下代码所示，将虚拟机的青年带设置为 10M，老年代设置为 20M，创建两个大对象，大小都为 15 M。

package org.gettingreal.jvm.learning.references;

/**
 * 强引用测试
 */
public class StrongReferenceTest {

    public static void main(String[] args) throws Exception {
        // 大小定位 15 M
        int size = 15 * 1024 * 1024;

        // 创建第一个对象
        byte[] firstBigObject = new byte[size];

        // 创建第二个对象
        byte[] secondBigObject = new byte[size];
    }
  
}

将代码编译后，执行如下命令来观察结果。

# 执行编译
mvn package -DskipTests

# 运行 StrongReferenceTest
java -XX:+PrintGC -Xmn10m -Xms30m -Xmx30m -classpath target/jvm-learnging-1.0.0-SNAPSHOT.jar org.gettingreal.jvm.learning.references.StrongReferenceTest

# 输出
[GC (Allocation Failure)  16195K->15960K(29696K), 0.0012633 secs]
[GC (Allocation Failure)  15960K->15944K(29696K), 0.0007246 secs]
[Full GC (Allocation Failure)  15944K->15672K(29696K), 0.0033753 secs]
[GC (Allocation Failure)  15672K->15672K(29696K), 0.0005597 secs]
[Full GC (Allocation Failure)  15672K->15659K(29696K), 0.0027816 secs]
Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
        at org.gettingreal.jvm.learning.references.StrongReferenceTest.main(StrongReferenceTest.java:16)

可以看出 JVM 执行多次 GC 操作，发现最终无法回收强引用的对象，抛出 OOM 异常。JVM 内部执行的步骤大体如下：

• 在创建第一个对象时，JVM 尝试在青年代进行分配
• 此时 JVM 发现青年代内存不够分配，将尝试在老年代进行分配
• 发现老年代的内存此时够用，将第一个对象分配在老年代
• 在创建第二个对象时，JVM 还是尝试在青年代进行分配，
• 此时 JVM 发现青年代内存不够分配，将尝试在老年代进行分配
• 此时 JVM 发现老年代内存也是不够用，虚拟机发生 GC 操作
• 发现老年代已分配的内存不能回收（因为第一个对象是强引用），抛出 OOM 异常

软引用（Soft Reference）

软引用表示一个对象有用，但是非必需的，意思是如果一个对象是软引用的，在内存空间充足的情况下，JVM 不会回收该对象。然后在内存空间不足时，JVM 会将该对象回收。

如下代码所示，测试软引用回收的情况，将虚拟机的青年带设置为 10M，老年代设置为 20M，创建两个大对象，大小都为 15 M。

package org.gettingreal.jvm.learning.references;

import java.lang.ref.SoftReference;

/**
 * 软引用测试
 */
public class SoftReferenceTest {

    public static void main(String[] args) throws Exception {
        // 大小定位 15 M
        int size = 15 * 1024 * 1024;

        // 创建第一个对象
        byte[] firstBigObject = new byte[size];

        // 将第一个对象加入到软引用对象中
        SoftReference softReference1 = new SoftReference(firstBigObject);

        // 需要手动释放掉强引用
        firstBigObject = null;


        // 创建第二个对象
        byte[] secondBigObject = new byte[size];

        // 将第一个对象加入到软引用对象中
        SoftReference softReference2 = new SoftReference(secondBigObject);

        // 需要手动释放掉强引用
        secondBigObject = null;
    }
  
}

将代码编译后，执行如下命令来观察结果。

# 执行编译
mvn package -DskipTests

# 运行 SoftReferenceTest
java -XX:+PrintGC -Xmn10m -Xms30m -Xmx30m -classpath target/jvm-learnging-1.0.0-SNAPSHOT.jar org.gettingreal.jvm.learning.references.SoftReferenceTest

# 输出
[GC (Allocation Failure)  16196K->15960K(29696K), 0.0006832 secs]
[GC (Allocation Failure)  15960K->15888K(29696K), 0.0006921 secs]
[Full GC (Allocation Failure)  15888K->15672K(29696K), 0.0031219 secs]
[GC (Allocation Failure)  15672K->15672K(29696K), 0.0003450 secs]
[Full GC (Allocation Failure)  15672K->299K(29696K), 0.0022771 secs]

可以观察到并没有发生 OOM 异常，说明 JVM 回收掉第一个大对象。

可以通过ReferenceQueue来观察引用被回收的情况，只要这个引用被回收，就会将引用添加到此队列中。

package org.gettingreal.jvm.learning.references;

import java.lang.ref.ReferenceQueue;
import java.lang.ref.SoftReference;

/**
 * 软引用队列测试
 */
public class SoftReferenceQueueTest {

    public static void main(String[] args) throws Exception {
        // 大小定位 15 M
        int size = 15 * 1024 * 1024;

        // 定义队列
        ReferenceQueue referenceQueue = new ReferenceQueue();

        try {
            // 创建第一个对象
            byte[] firstBigObject = new byte[size];

            // 将第一个对象加入到软引用对象中
            SoftReference softReference1 = new SoftReference(firstBigObject, referenceQueue);
            System.out.println("添加软引用：" + softReference1);

            // 需要手动释放掉强引用
            firstBigObject = null;


            // 创建第二个对象
            byte[] secondBigObject = new byte[size];

            // 将第一个对象加入到软引用对象中
            SoftReference softReference2 = new SoftReference(secondBigObject, referenceQueue);
            System.out.println("添加软引用：" + softReference2);

            // 需要手动释放掉强引用
            secondBigObject = null;
        } finally {
            SoftReference softReference = null;
            while ((softReference = (SoftReference) referenceQueue.poll()) != null) {
                System.out.println("回收软引用：" + softReference);
            }
        }

    }

}

将代码编译后，执行如下命令来观察结果。

# 执行编译
mvn package -DskipTests

# 运行 SoftReferenceQueueTest
java -Xmn10m -Xms30m -Xmx30m -classpath target/jvm-learnging-1.0.0-SNAPSHOT.jar org.gettingreal.jvm.learning.references.SoftReferenceQueueTest

# 输出
添加软引用：java.lang.ref.SoftReference@3d4eac69
[GC (Allocation Failure)  16197K->15976K(29696K), 0.0009770 secs]
[GC (Allocation Failure)  15976K->15912K(29696K), 0.0005638 secs]
[Full GC (Allocation Failure)  15912K->15674K(29696K), 0.0039520 secs]
[GC (Allocation Failure)  15674K->15674K(29696K), 0.0004479 secs]
[Full GC (Allocation Failure)  15674K->301K(29696K), 0.0026771 secs]
添加软引用：java.lang.ref.SoftReference@42a57993
回收软引用：java.lang.ref.SoftReference@3d4eac69

可以看出，第一个软引用被回收了。

弱引用（Weak Reference）

类似于软引用，但是比软引用还要弱一些，用来描述非必需的对象，只要发生 GC 操作，弱引用都会被回收。

如下代码所示，测试弱引用回收的情况，将虚拟机的青年带设置为 10M，老年代设置为 20M，创建两个大对象，大小都为 15 M。

package org.gettingreal.jvm.learning.references;

import java.lang.ref.ReferenceQueue;
import java.lang.ref.WeakReference;

/**
 * 弱引用测试
 */
public class WeakReferenceTest {

    public static void main(String[] args) throws Exception {
        // 大小定位 15 M
        int size = 15 * 1024 * 1024;

        // 定义队列
        ReferenceQueue referenceQueue = new ReferenceQueue();

        try {
            // 创建第一个对象
            byte[] firstBigObject = new byte[size];

            // 将第一个对象加入到弱引用对象中
            WeakReference weakReference = new WeakReference(firstBigObject, referenceQueue);
            System.out.println("添加弱引用：" + weakReference);

            // 需要手动释放掉强引用
            firstBigObject = null;


            // 创建第二个对象
            byte[] secondBigObject = new byte[size];

            // 将第一个对象加入到弱引用对象中
            WeakReference weakReference2 = new WeakReference(secondBigObject, referenceQueue);
            System.out.println("添加弱引用：" + weakReference2);

            // 需要手动释放掉强引用
            secondBigObject = null;

            // 执行一次 gc 操作
            System.gc();
        } finally {
            WeakReference wr = null;
            while ((wr = (WeakReference) referenceQueue.poll()) != null) {
                System.out.println("回收弱引用：" + wr);
            }
        }

    }

}

将代码编译后，执行如下命令来观察结果。

# 执行编译
mvn package -DskipTests

# 运行 WeakReferenceTest
java -XX:+PrintGC -Xmn10m -Xms30m -Xmx30m -classpath target/jvm-learnging-1.0.0-SNAPSHOT.jar org.gettingreal.jvm.learning.references.WeakReferenceTest

# 输出
添加弱引用：java.lang.ref.WeakReference@3d4eac69
[GC (Allocation Failure)  16197K->15960K(29696K), 0.0008933 secs]
[GC (Allocation Failure)  15960K->15928K(29696K), 0.0008108 secs]
[Full GC (Allocation Failure)  15928K->314K(29696K), 0.0029523 secs]
添加弱引用：java.lang.ref.WeakReference@42a57993
[GC (System.gc())  15838K->15706K(29696K), 0.0004367 secs]
[Full GC (System.gc())  15706K->308K(29696K), 0.0023688 secs]
回收弱引用：java.lang.ref.WeakReference@42a57993
回收弱引用：java.lang.ref.WeakReference@3d4eac69

可以发现，只要发生 GC 操作，弱引用都将会被回收。

虚引用（Phantom Reference）

虚引用实际上是为了资源释放的细粒度控制，但是使用虚引用却需要小心，因为虚引用可能会导致 OOM 的发生。虚引用更倾向于实现程序员对内存回收的细粒度控制，当虚引用会被回收时，向引用系统发出通知，此时可以执行内存的释放相关操作。

虚引用不会主动释放其指向的对象的内存区域，所以当内存满时，会导致 OOM 异常的发生。将虚拟机的青年带设置为 10M，老年代设置为 20M，创建两个大对象，大小都为 15 M。如下代码所示：

package org.gettingreal.jvm.learning.references;

import java.lang.ref.PhantomReference;
import java.lang.ref.ReferenceQueue;

/**
 * 虚引用测试
 */
public class PhantomReferenceTest {

    public static void main(String[] args) {
        int size = 15 * 1024 * 1024;
        ReferenceQueue referenceQueue = null;

        try {
            // 定义队列
            referenceQueue = new ReferenceQueue();

            // 将第一个对象加入到软虚用对象中
            PhantomReference phantomReference1 = new PhantomReference(new byte[size], referenceQueue);
            System.out.println("添加虚引用，phantomReference1：" + phantomReference1);

            // 将第一个对象加入到软引用对象中
            PhantomReference phantomReference2 = new PhantomReference(new byte[size], referenceQueue);
            System.out.println("添加虚引用，phantomReference2：" + phantomReference2);

            System.gc();
        } finally {
            System.out.println("\n检查回收虚引用：");
            PhantomReference pr = null;
            while ((pr = (PhantomReference) referenceQueue.poll()) != null) {
                System.out.println("回收虚引用：" + pr);
            }
        }

    }

}

将代码编译后，执行如下命令来观察结果。

# 执行编译
mvn package -DskipTests

# 运行 PhantomReferenceTest
java -XX:+PrintGC -Xmn10m -Xms30m -Xmx30m -classpath target/jvm-learnging-1.0.0-SNAPSHOT.jar org.gettingreal.jvm.learning.references.PhantomReferenceTest

# 输出
添加虚引用，phantomReference1：java.lang.ref.PhantomReference@3d4eac69
[GC (Allocation Failure)  16197K->15960K(29696K), 0.0006786 secs]
[GC (Allocation Failure)  15960K->15896K(29696K), 0.0007171 secs]
[Full GC (Allocation Failure)  15896K->15674K(29696K), 0.0032693 secs]
[GC (Allocation Failure)  15674K->15674K(29696K), 0.0005009 secs]
[Full GC (Allocation Failure)  15674K->15661K(29696K), 0.0024825 secs]

检查回收虚引用：
回收虚引用：java.lang.ref.PhantomReference@3d4eac69
Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
        at org.gettingreal.jvm.learning.references.PhantomReferenceTest.main(PhantomReferenceTest.java:24)

可以看出并没有释放 phantomReference1对应的内存。可以通过手动调用 PhantomReference 实例的 clear() 方法来释放对应的内存。

package org.gettingreal.jvm.learning.references;

import java.lang.ref.PhantomReference;
import java.lang.ref.ReferenceQueue;

/**
 * 虚引用清理测试
 */
public class PhantomReferenceCleanTest {

    public static void main(String[] args) throws Exception {
        int size = 15 * 1024 * 1024;
        ReferenceQueue referenceQueue = null;

        try {
            // 定义队列
            referenceQueue = new ReferenceQueue();

            // 将第一个对象加入到软虚用对象中
            PhantomReference phantomReference = new PhantomReference(new byte[size], referenceQueue);
            System.out.println("添加虚引用，phantomReference1：" + phantomReference);

            System.gc();
        } finally {
            System.out.println("\n检查回收虚引用：");
            PhantomReference pr = null;
            while ((pr = (PhantomReference) referenceQueue.poll()) != null) {
                System.out.println("回收虚引用：" + pr);

                // 调用 clear() 方法，模拟内存释放的细粒度操作
                pr.clear();
            }
        }

        try {
            Thread.sleep(3000);
            // 将第二个对象加入到软虚用对象中
            PhantomReference phantomReference2 = new PhantomReference(new byte[size], referenceQueue);
            System.out.println("添加虚引用，phantomReference2：" + phantomReference2);

            System.gc();
        } finally {
            System.out.println("\n检查回收虚引用2：");
            PhantomReference pr = null;
            while ((pr = (PhantomReference) referenceQueue.poll()) != null) {
                System.out.println("回收虚引用：" + pr);

                // 调用 clear() 方法，模拟内存释放的细粒度操作
                pr.clear();
            }
        }

    }

}

将代码编译后，执行如下命令来观察结果。

# 执行编译
mvn package -DskipTests

# 运行 PhantomReferenceCleanTest
java -XX:+PrintGC -Xmn10m -Xms30m -Xmx30m -classpath target/jvm-learnging-1.0.0-SNAPSHOT.jar org.gettingreal.jvm.learning.references.PhantomReferenceCleanTest

# 输出
添加虚引用，phantomReference1：java.lang.ref.PhantomReference@3d4eac69
[GC (System.gc())  16197K->15992K(29696K), 0.0009614 secs]
[Full GC (System.gc())  15992K->15675K(29696K), 0.0032103 secs]

检查回收虚引用：
回收虚引用：java.lang.ref.PhantomReference@3d4eac69
[GC (Allocation Failure)  15839K->15739K(29696K), 0.0012892 secs]
[GC (Allocation Failure)  15739K->15771K(29696K), 0.0007469 secs]
[Full GC (Allocation Failure)  15771K->308K(29696K), 0.0042175 secs]
添加虚引用，phantomReference2：java.lang.ref.PhantomReference@42a57993
[GC (System.gc())  15832K->15700K(29696K), 0.0004901 secs]
[Full GC (System.gc())  15700K->15669K(29696K), 0.0018866 secs]

检查回收虚引用2：
回收虚引用：java.lang.ref.PhantomReference@42a57993

可以发现，phantomReference1 在 GC 操作时，加入到了 referenceQueue 队列，在遍历队列时，调用引用的 clean() 方法来执行对象对应内存的释放。再次添加一个对象时，不会出现 OOM 异常。