Java 中的四种引用类型----强引用、弱引用、软引用、虚引用

一、背景

Java的内存回收不需要程序员负责，JVM会在必要时启动Java GC完成垃圾回收。Java以便我们控制对象的生存周期，提供给了我们四种引用方式，引用强度从强到弱分别为：强引用、软引用、弱引用、虚引用。

---

二、简介

1.强引用StrongReference

StrongReference是Java的默认引用形式，使用时不需要显示定义。任何通过强引用所使用的对象不管系统资源有多紧张，Java GC都不会主动回收具有强引用的对象。

package com.test.reference;

/**
 * @author: hyl
 * @date: 2019/10/20
 **/
public class StrongReferenceTest {

    public static int M = 1024 * 1024;

    public static void printMemory(String tag){
        Runtime runtime = Runtime.getRuntime();
        int M = StrongReferenceTest.M;
        System.out.println("\n" + tag + ":");
        System.out.println(runtime.freeMemory() / M + "M(free)/" + runtime
        .totalMemory() / M + "M(total)");
    }

    public static void main(String[] args) {
        StrongReferenceTest.printMemory("1.原可用内存和总内存");

        //实例化10M的数组并与strongReference建立强引用
        byte[] strongRerence = new byte[10 * StrongReferenceTest.M];
        StrongReferenceTest.printMemory("2.实例化10M的数组,并建立强引用");
        System.out.println("strongReference : " + strongRerence);


        System.gc();
        StrongReferenceTest.printMemory("3.GC后");
        System.out.println("strongReference : " + strongRerence);

        //strongReference = null后,强引用断开了
        strongRerence = null;
        StrongReferenceTest.printMemory("4.强引用断开后");
        System.out.println("strongReference : " + strongRerence);

        System.gc();
        StrongReferenceTest.printMemory("5.GC后");
        System.out.println("strongReference : " + strongRerence);

    }
}

运行结果：

结论：

在第一次发生GC时strongReference并没有变为空，说明强引用并不会被主动回收。

---

2.弱引用StrongReference

如果一个对象只具有弱引用，无论内存充足与否，Java GC后对象如果只有弱引用将会被自动回收。

package com.test.reference;

import java.lang.ref.WeakReference;

/**
 * @author: hyl
 * @date: 2019/10/20
 **/
public class WeakReferenceTest {

    public static int M = 1024 * 1024;

    public static void printMemory(String tag){
        Runtime runtime = Runtime.getRuntime();
        int M = StrongReferenceTest.M;
        System.out.println("\n" + tag + ":");
        System.out.println(runtime.freeMemory() / M + "M(free)/" + runtime
                .totalMemory() / M + "M(total)");
    }

    public static void main(String[] args) {

        WeakReferenceTest.printMemory("1.原可用内存和总内存");

        //创建弱引用
        WeakReference<Object> weakReference = new WeakReference<Object>(new byte[10 * WeakReferenceTest.M]);
        WeakReferenceTest.printMemory("2.实例化10M的数组,并建立弱引用");
        System.out.println("weakReference.get() : " + weakReference.get());

        System.gc();
        WeakReferenceTest.printMemory("3.GC后");
        System.out.println("weakReference.get() : " + weakReference.get());
    }
}

运行结果：

结论：

在发生GC时weakReference引用为null，说明被回收了。

---

3.软引用StrongReference

软引用和弱引用的特性基本一致， 主要的区别在于软引用在内存不足时才会被回收。如果一个对象只具有软引用，Java GC在内存充足的时候不会回收它，内存不足时才会被回收。

package com.test.reference;

import java.lang.ref.SoftReference;

/**
 * @author: hyl
 * @date: 2019/10/20
 **/
public class SoftReferenceTest {

    public static int M = 1024 * 1024;

    public static void printMemory(String tag){
        Runtime runtime = Runtime.getRuntime();
        int M = StrongReferenceTest.M;
        System.out.println("\n" + tag + ":");
        System.out.println(runtime.freeMemory() / M + "M(free)/" + runtime
                .totalMemory() / M + "M(total)");
    }

    public static void main(String[] args) {
        System.out.println("1.原可用内存和总内存");


        //建立软引用
        SoftReference<Object> softReference = new SoftReference<Object>(new byte[10 * SoftReferenceTest.M]);
        SoftReferenceTest.printMemory("2.实例化10M的数组,并建立软引用");
        System.out.println("softReference.get() : " + softReference.get());

        System.gc();
        SoftReferenceTest.printMemory("3.内存可用容量充足,GC后");
        System.out.println("softReference.get() : " + softReference.get());

        //实例化一个数组,使内存不够用,并建立软引用
        SoftReference<Object> softReference1 = new SoftReference<Object>(new byte[170 * SoftReferenceTest.M]);
        SoftReferenceTest.printMemory("4.实例化一个170M的数组");
        System.out.println("softReference.get() : " + softReference.get());
        System.out.println("softReference1.get() : " + softReference1.get());
    }
}

运行结果：

结论：

可以很清晰的看到，在内存充足发生GC时，softReference不会被回收；而在内存不够的时候，会把之前的softReference进行回收。

---

4.虚引用StrongReference

从PhantomReference类的源代码可以知道，它的get()方法无论何时返回的都只会是null。所以单独使用虚引用时，没有什么意义，需要和引用队列ReferenceQueue类联合使用。当执行Java GC时如果一个对象只有虚引用，就会把这个对象加入到与之关联的ReferenceQueue中。

package com.test.reference;

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

/**
 * @author: hyl
 * @date: 2019/10/20
 **/
public class PhantomReferenceTest {
    public static int M = 1024 * 1024;

    public static void printlnMemory(String tag){

        Runtime runtime = Runtime.getRuntime();
        int M = PhantomReferenceTest.M;
        System.out.println("\n" + tag + ":");
        System.out.println(runtime.freeMemory() / M + "M(free)/"
                + runtime.totalMemory()/M + "M(total)");
    }


    public static void main(String[] args){

        PhantomReferenceTest.printlnMemory("1.原可用内存和总内存");
        byte[] object = new byte[10 * PhantomReferenceTest.M];
        PhantomReferenceTest.printlnMemory("2.实例化10M的数组后");


        //建立虚引用
        ReferenceQueue<Object> referenceQueue = new ReferenceQueue<Object>();
        PhantomReference<Object> phantomReference = new
                PhantomReference<Object>(object,referenceQueue);

        PhantomReferenceTest.printlnMemory("3.建立虚引用后");
        System.out.println("phantomReference : " + phantomReference);
        System.out.println("phantomReference.get() : " + phantomReference.get());
        System.out.println("referenceQueue.poll() : " + referenceQueue.poll());


        //断开byte[10 * PhantomReferenceTest.M]的强引用
        object = null;
        PhantomReferenceTest.printlnMemory("4.执行object = null;强引用断开后");

        System.gc();
        PhantomReferenceTest.printlnMemory("5.GC后");
        System.out.println("phantomReference : " + phantomReference);
        System.out.println("phantomReference.get() : " + phantomReference);
        System.out.println("referenceQueue.poll() : " + referenceQueue.poll());


        //断开虚引用
        phantomReference = null;
        System.gc();
        PhantomReferenceTest.printlnMemory("6.断开虚引用后GC");
        System.out.println("phantomReference : " + phantomReference);
        System.out.println("referenceQueue.poll() : " + referenceQueue.poll());
    }
}

运行结果：

---

三、小结

强引用是 Java 的默认引用形式，使用时不需要显示定义，是我们平时最常使用到的引用方式。不管系统资源有多紧张，Java GC都不会主动回收具有强引用的对象。 弱引用和软引用一般在引用对象为非必需对象的时候使用。它们的区别是被弱引用关联的对象在垃圾回收时总是会被回收，被软引用关联的对象只有在内存不足时才会被回收。 虚引用的get()方法获取的永远是null，无法获取对象实例。Java GC会把虚引用的对象放到引用队列里面。可用来在对象被回收时做额外的一些资源清理或事物回滚等处理。 由于无法从虚引获取到引用对象的实例。

---

文章为ArvinHan原创,如果文章有错的地方欢迎指正，大家互相交流。