Java中的四种引用

强引用 (StrongReference)

Java中大部分的对象都是强引用，一个对象如果被强引用，内存不足时,JVM会抛出OutOfMemory错误，有不会回收。如下面的测试代码：

import java.util.ArrayList;

public class Test {

    static ArrayList<Byte[]> byteArrayArrayList = new ArrayList<Byte[]>();
    Byte[] mBytes = new Byte[10000000];

    void test() {
        for (;;) {
            byteArrayArrayList.add(new Byte[100000]);
            if (mBytes == null) {
                System.out.print("mBytes become null");
            }
        }
    }

    /**
     * @param args
     */
    public static void main(String[] args) {
        Test test = new Test();
        test.test();
    }
}

输出如下：

Exception in thread "main" java.lang.OutOfMemoryError: Java heap space

at Test.test(Test.java:13)

at Test.main(Test.java:25)
从log可以看出，出现OutofMemoryError前，夜没有打出mObject become null。

软引用 (SoftReference)

软引用用于引用一些有用，但是不必要的对象，当内存不足时，JVM会回收这一部分对象。软引用使用时，需要先检查状态。

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

public class Test {

    static ArrayList<Byte[]> byteArrayArrayList = new ArrayList<Byte[]>();

    SoftReference<Byte[]> mBytes = new SoftReference<Byte[]>(new Byte[100000]);

    void test() {
        for (;;) {
            byteArrayArrayList.add(new Byte[100000]);
            if (mBytes.get() == null) {
                System.out.print("mBytes become null \r\n");
            }
        }
    }

    /**
     * @param args
     */
    public static void main(String[] args) {
        Test test = new Test();
        test.test();
    }
}

输出结果如下：

mBytes become null count:4148
Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
at Test.test(Test.java:13)
at Test.main(Test.java:25)

可以看出OOM之前 mBytes被回收。

弱引用

弱引用和软引用类似，每次GC时，JVM都会回收这一部分对象。软引用使用时，需要先检查状态。

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

public class Test {

    static ArrayList<Byte[]> byteArrayArrayList = new ArrayList<Byte[]>();

    WeakReference<Byte[]> mBytes = new WeakReference<Byte[]>(new Byte[100000]);

    void test() {
        int count = 0;
        for (;; count++) {
            byteArrayArrayList.add(new Byte[100000]);
            System.gc();
            if (mBytes.get() == null) {
                System.out.print("mBytes become null count:" + count + "\r\n");
                break;
            }
        }
    }

    /**
     * @param args
     */
    public static void main(String[] args) {
        Test test = new Test();
        test.test();
    }
}

输出如下：

mBytes become null count:0

可以看出，调用System.gc();后mBytes很快就被回收，循环也就终止了。

虚引用

虚引用并不影响对象的生命周期，其作用时跟踪对象是否要被GC,虚引用必须和ReferenceQueue配合使用。

import java.lang.ref.PhantomReference;
import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;
import java.util.ArrayList;

public class Test {

    static ArrayList<Byte[]> byteArrayArrayList = new ArrayList<Byte[]>();

    ReferenceQueue<Object> mQueue = new ReferenceQueue<Object>();
    PhantomReference<Object> mPhatom;

    void test() {
        int count = 0;
        test2();
        for (;; count++) {
            byteArrayArrayList.add(new Byte[100000]);
            Reference<Object> ref = (Reference<Object>) mQueue.poll();
            System.out.print("ref is " + ref + " mPhatom:" + mPhatom + " mPhatom.get() is "
                    + mPhatom.get() + "\r\n");

            if (ref == mPhatom) {
                System.out.print("obj is about to gc count:" + count + "\r\n");
                break;
            }
            System.gc();
        }
    }

    void test2() {
        Object obj = new Object();

        mPhatom = new PhantomReference<Object>(obj, mQueue);
        System.out.print("obj is " + obj + " mPhatom.get() is " + mPhatom.get() + "\r\n");
    }

    /**
     * @param args
     */
    public static void main(String[] args) {
        Test test = new Test();
        test.test();
    }
}

输出结果为：