前幾天發了一篇關于垃圾收集的帖子，自己也不是這方面的專家，所以肯定有很多問題和錯誤，也請大家多多包涵和指教。

今天再進一步談一下這個幾個Reference吧。老實說，這幾個名詞我也是最近才聽說，平時也沒有實際使用過，但是確實在java 1.2就存在的，看來真的是學無止境啊。

• softly reachable ：The object is the referent of a SoftReference . The garbage collector will attempt to preserve the object as long as possible, but will collect it before throwing an OutOfMemoryError.
• weakly reachable ：The object is the referent of a WeakReference , and there are no strong or soft references to it. The garbage collector is free to collect the object at any time, with no attempt to preserve it.
• phantom reachable ：The object is the referent of a PhantomReference , and there are no strong, soft, or weak references to it. This reference type differs from the other two in that it isn't meant to be used to access the object, but as a signal that the object has already been finalized, and the garbage collector is ready to reclaim its memory.

在《Thinking in Java》第四版是如此描述：In the order of SoftReference, WeakReference, and PhantomReference, each one is "weaker" than the last and corresponds to a different level of reachability. Soft references are for implementing memory-sensitive caches. Weak references are for implementing "canonicalizing mappings"—where instances of objects can be simultaneously used in multiple places in a program, to save storage—that do not prevent their keys (or values) from being reclaimed. Phantom references are for scheduling pre-mortem cleanup actions in a more flexible way than is possible with the Java finalization mechanism.

在引入了這幾個引用之后，對象的生命周期【1】：

import java.lang.ref.*; public class References { public static void main(String[] args) { Object softObj, weakObj, phantomObj; Reference ref; WeakReference weakRef; SoftReference softRef; PhantomReference phantomRef; ReferenceQueue softQueue, weakQueue, phantomQueue; softObj = new String("Soft Reference"); weakObj = new String("Weak Reference"); phantomObj = new String("Phantom Reference"); softQueue = new ReferenceQueue(); weakQueue = new ReferenceQueue(); phantomQueue = new ReferenceQueue(); softRef = new SoftReference(softObj, softQueue); weakRef = new WeakReference(weakObj, weakQueue); phantomRef = new PhantomReference(phantomObj, phantomQueue); // Print referents to prove they exist. Phantom referents // are inaccessible so we should see a null value. System.out.println("Soft Referenc: "+ softRef.get()); System.out.println("Weak Reference: " + weakRef.get()); System.out.println("Phantom Reference: " + phantomRef.get()); // Clear all strong references softObj = null; weakObj = null; phantomObj = null; // Reach object via reference System.out.println("Soft Referenc: "+ softRef.get()); System.out.println("Weak Reference: " + weakRef.get()); System.out.println("Phantom Reference: " + phantomRef.get()); // Check the queue before garbage collection System.out.println("Soft Queued: "+ softRef.isEnqueued()); System.out.println("Weak Queued: " + weakRef.isEnqueued()); System.out.println("Phantom Queued: " + phantomRef.isEnqueued()); // Invoke garbage collector in hopes that references will be queued System.gc(); // Try to finalize the phantom references if not already if (!phantomRef.isEnqueued()) { System.out.println("Requestion finalization."); System.runFinalization(); } // See if the garbage collector has queued the references System.out.println("Soft Queued: "+ softRef.isEnqueued()); System.out.println("Weak Queued: " + weakRef.isEnqueued()); System.out.println("Phantom Queued: " + phantomRef.isEnqueued()); try { // Test soft reference if(softRef.isEnqueued()){ System.out.println("Soft Referenc in the Queue"); ref = softQueue.remove(); System.out.println("Soft Queued: "+ ref.get()); } else{ System.out.println("Soft Referenc not in the Queue"); } // Test weak reference if(weakRef.isEnqueued()){ System.out.println("Weak Referenc in the Queue"); ref = weakQueue.remove(); System.out.println("Weak Reference: " + ref.get()); } else{ System.out.println("Weak Referenc not in the Queue"); } // Test Phantom reference if(phantomRef.isEnqueued()){ System.out.println("Phantom Referenc in the Queue"); ref = phantomQueue.remove(); System.out.println("Phantom Reference: " + ref.get()); // We have to clear the phantom referent even though // get() returns null ref.clear(); } else{ System.out.println("Phantom Referenc not in the Queue"); } } catch (InterruptedException e) { e.printStackTrace(); return; } } }

上面這段代碼演示了幾種引用的特性：

• PhantomReference 總是返回null
• 垃圾收集之后 PhantomReference ， WeakReference 都進去了queue，而 SoftReference 沒有。證明 SoftReference 生命周期更長。

下面這個例子來自《Thinking in Java》第四版，稍作修改：

//: containers/References.java //Demonstrates Reference objects from <Thinking in Java> 4th edition section "Holding references" import java.lang.ref.*; import java.util.*; class VeryBig { private static final int SIZE = 10000; private long[] la = new long[SIZE]; private String ident; public VeryBig(String id) { ident = id; } public String toString() { return ident; } public String getID() { return ident; } protected void finalize() { System.out.println("Finalizing " + ident); } } public class ReferencesTIJ { private static ReferenceQueue<VeryBig> rq = new ReferenceQueue<VeryBig>(); public static void checkQueue() { Reference<? extends VeryBig> inq = rq.poll(); referenceType(inq); } private static void referenceType(Reference<? extends VeryBig> inq) { if (inq != null) { if (inq instanceof PhantomReference) System.out.println("PhantomReference In queue: " + inq.get()); if (inq instanceof WeakReference) System.out.println("WeakReference In queue: " + inq.get()); if (inq instanceof SoftReference) System.out.println("SoftReference In queue: " + inq.get()); } } public static void main(String[] args) { int size = 10; // Or, choose size via the command line: if (args.length > 0) size = new Integer(args[0]); LinkedList<SoftReference<VeryBig>> sa = new LinkedList<SoftReference<VeryBig>>(); for (int i = 0; i < size; i++) { sa.add(new SoftReference<VeryBig>(new VeryBig("Soft " + i), rq)); System.out.println("Just created <" + i + "> : " + sa.getLast().toString()); checkQueue(); } LinkedList<WeakReference<VeryBig>> wa = new LinkedList<WeakReference<VeryBig>>(); for (int i = 0; i < size; i++) { wa.add(new WeakReference<VeryBig>(new VeryBig("Weak " + i), rq)); System.out.println("Just created <" + i + "> : " + wa.getLast().toString()); checkQueue(); } SoftReference<VeryBig> s = new SoftReference<VeryBig>(new VeryBig( "Soft Last")); WeakReference<VeryBig> w = new WeakReference<VeryBig>(new VeryBig( "Weak Last")); System.gc(); LinkedList<PhantomReference<VeryBig>> pa = new LinkedList<PhantomReference<VeryBig>>(); for (int i = 0; i < size; i++) { pa.add(new PhantomReference<VeryBig>(new VeryBig("Phantom " + i), rq)); System.out.println("Just created <" + i + "> : " + pa.getLast()); } //System.runFinalization(); Reference<? extends VeryBig> ref; while ((ref = rq.poll()) != null) { if (ref != null) { referenceType(ref); } } } }

這個例子比較有意思，每次執行，結果都會有一些差異。至于為什么，我也在研究之中，歡迎大家指教！

參考：

【1】 http://www.kdgregory.com/index.php?page=java.refobj

【2】 http://improving.iteye.com/blog/436311

WeakReference，SoftReference 和 PhatomReference 淺析