深入理解StrongReference，SoftReference， WeakReference和PhantomReference

Java 中一共有 4 种类型的引用 : StrongReference、 SoftReference、 WeakReference 以及 PhantomReference (传说中的幽灵引用 呵呵), 

这 4 种类型的引用与 GC 有着密切的关系,  让我们逐一来看它们的定义和使用场景 :

1. Strong Reference

       StrongReference 是 Java 的默认引用实现,  它会尽可能长时间的存活于 JVM 内， 当没有任何对象指向它时 GC 执行后将会被回收

@Test

public void strongReference() {

Object referent = new Object();



/**

* 通过赋值创建 StrongReference 

*/

Object strongReference = referent;



assertSame(referent, strongReference);



referent = null;

System.gc();



/**

* StrongReference 在 GC 后不会被回收

*/

assertNotNull(strongReference);

}

2. WeakReference & WeakHashMap

    WeakReference， 顾名思义,  是一个弱引用,  当所引用的对象在 JVM 内不再有强引用时, GC 后 weak reference 将会被自动回收

@Test

public void weakReference() {

Object referent = new Object();

WeakReference<Object> weakRerference = new WeakReference<Object>(referent);



assertSame(referent, weakRerference.get());



referent = null;

System.gc();



/**

* 一旦没有指向 referent 的强引用, weak reference 在 GC 后会被自动回收

*/

assertNull(weakRerference.get());

}

WeakHashMap 使用 WeakReference 作为 key， 一旦没有指向 key 的强引用, WeakHashMap 在 GC 后将自动删除相关的 entry

@Test

public void weakHashMap() throws InterruptedException {

Map<Object, Object> weakHashMap = new WeakHashMap<Object, Object>();

Object key = new Object();

Object value = new Object();

weakHashMap.put(key, value);



assertTrue(weakHashMap.containsValue(value));



key = null;

System.gc();



/**

* 等待无效 entries 进入 ReferenceQueue 以便下一次调用 getTable 时被清理

*/

Thread.sleep(1000);



/**

* 一旦没有指向 key 的强引用, WeakHashMap 在 GC 后将自动删除相关的 entry

*/

assertFalse(weakHashMap.containsValue(value));

}

3. SoftReference

    SoftReference 于 WeakReference 的特性基本一致， 最大的区别在于 SoftReference 会尽可能长的保留引用直到 JVM 内存不足时才会被回收(虚拟机保证), 这一特性使得 SoftReference 非常适合缓存应用

@Test

public void softReference() {

Object referent = new Object();

SoftReference<Object> softRerference = new SoftReference<Object>(referent);



assertNotNull(softRerference.get());



referent = null;

System.gc();



/**

*  soft references 只有在 jvm OutOfMemory 之前才会被回收, 所以它非常适合缓存应用

*/

assertNotNull(softRerference.get());

}

SoftReference比WeakReference生命力更强，当JVM的内存不吃紧时，即使引用的对象被置为空了，Soft还可以保留对该对象的引用，此时的JVM内存池实际上还保有原来对象，只有当内存吃紧的情况下JVM才会清除Soft的引用对象，并且会在未来重新加载该引用的对象。 

而WeakReference则当清理内存池时会自动清理掉引用的对象。

4、PhantomRefrence(虚引用)

     虚顾名思义就是没有的意思，建立虚引用之后通过get方法返回结果始终为null,通过源代码你会发现,虚引用通向会把引用的对象写进referent,只是get方法返回结果为null.先看一下和gc交互的过程在说一下他的作用.

  1、不把referent设置为null, 直接把heap中的new String("abc")对象设置为可结束的(finalizable).

  2、与软引用和弱引用不同, 先把PhantomRefrence对象添加到它的ReferenceQueue中.然后在释放虚可及的对象.

   你会发现在收集heap中的new String("abc")对象之前,你就可以做一些其他的事情.通过以下代码可以了解他的作用.

import java.lang.ref.PhantomReference;   

import java.lang.ref.Reference;   

import java.lang.ref.ReferenceQueue;   

import java.lang.reflect.Field;   

   

public class Test {   

    public static boolean isRun = true;   

   

    public static void main(String[] args) throws Exception {   

        String abc = new String("abc");   

        System.out.println(abc.getClass() + "@" + abc.hashCode());   

        final ReferenceQueue referenceQueue = new ReferenceQueue<String>();   

        new Thread() {   

           public void run() {   

                while (isRun) {   

                    Object o = referenceQueue.poll();   

                    if (o != null) {   

                        try {   

                            Field rereferent = Reference.class   

                                    .getDeclaredField("referent");   

                            rereferent.setAccessible(true);   

                            Object result = rereferent.get(o);   

                            System.out.println("gc will collect:"   

                                    + result.getClass() + "@"   

                                    + result.hashCode());   

                        } catch (Exception e) {   

   

                            e.printStackTrace();   

                        }   

                    }   

                }   

            }   

        }.start();   

        PhantomReference<String> abcWeakRef = new PhantomReference<String>(abc,   

                referenceQueue);   

        abc = null;   

        Thread.currentThread().sleep(3000);   

        System.gc();   

        Thread.currentThread().sleep(3000);   

        isRun = false;   

    }   

}

结果为

class java.lang.String@96354   

gc will collect:class java.lang.String@96354