深入理解StrongReference，SoftReference， WeakReference和PhantomReference

Posted 2022-08-13 火山石

    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