java中的引用分為4種：String Reference， WeakReference， softReference，PhantomReference
Strong Reference:
我們平常用的最多的就是強引用了
如：String s = new String("opps");這種形式的引用稱為強引用，這種引用有以下幾個特點
1.強引用可以直接訪問目標對象 ;
2.強引用所指向的對象在任何時候都不會被系統回收 ;
3.由于2的原因,強引用可能導致內存泄漏。
StrongReference 是 Java 的默認引用實現, 強引用指向的對象，垃圾回收器不會自動幫你回收對象所占的內存，一旦對象被強引用，那么強引用本身就強迫這個對象保留在內存中，因此需要你自己手動去釋放不需要再次別使用的對象所占的空間，它會盡可能長時間的存活于 JVM 內， 當沒有任何對象指向它時 GC 執行后將會被回收。
public void testStrongReference() {
Object referent = new Object();
/**
* 通過賦值創建 StrongReference
*/
Object strongReference = referent;
assertSame(referent, strongReference);
referent = null;
System.gc();
/**
* StrongReference 在 GC 后不會被回收
*/
assertNotNull(strongReference);
}
WeakReference， 顧名思義, 是一個弱引用, 當所引用的對象在 JVM 內不再有強引用時, GC 后 weak reference 將會被自動回收
public void testWeakReference() {
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());
}
public void testWeakHashMap() 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));
}
SoftReference 于 WeakReference 的特性基本一致， 最大的區別在于 SoftReference 會盡可能長的保留引用直到 JVM 內存不足時才會被回收(虛擬機保證), 這一特性使得 SoftReference 非常適合緩存應用
可用來實現智能緩存（java.lang.ref.SoftReference is a relatively new class, used to implement smart caches.）假定你有一個對象引用，指向一個大數組：
Object obj = new char[1000000];
并且如果可能的話，你打算一直保存這個數組，但是如果內存極其短缺的話，你樂于釋放這個數組。你可以使用一個
soft reference:
SoftReference ref = new SoftReference(obj);
Obj是這個soft reference的引用。在以后你用以下的方式檢測這個引用：
if (ref.get() == null)// (referent has been cleared)
else// (referent has not been cleared)
如果這個引用已經被清除了，那么垃圾回收器會收回它所使用的空間，并且你緩存的對象也已經消失。需要注意的是，如果這個指示物還有對它的別的引用，那么垃圾回收器將不會清除它。這個方案可以被用來實現各種不同類型的緩存，這些緩存的特點是只要有可能對象就會被一直保存下來，但是如果內存緊張對象就被清除掉。
注意：軟引用可以和一個引用隊列（ReferenceQueue）聯合使用，如果軟引用所引用的對象被垃圾回收，Java虛擬機就會把這個軟引用加入到與之關聯的引用隊列中。
public void testSoftReference() {
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());
}
PhantomReference
Phantom Reference(幽靈引用) 與 WeakReference 和 SoftReference 有很大的不同, 因為它的 get() 方法永遠返回 null, 這也正是它名字的由來. PhantomReference 唯一的用處就是跟蹤 referent 何時被 enqueue 到 ReferenceQueue 中.
public void testPhantomReferenceAlwaysNull() {
Object referent = new Object();
PhantomReference<Object> phantomReference = new PhantomReference<Object>(referent, new ReferenceQueue<Object>());
/**
* phantom reference 的 get 方法永遠返回 null
*/
assertNull(phantomReference.get());
}
當GC在遍歷引用關系時，如果發現被phantom reference包裝過的referent不存在strong, weak, soft引用時(就是除phantom外沒有任何引用，幻影的由來)，GC會將 phantom reference 放入 Reference queue。以便程序在另一邊通過queue的remove/poll方法，感知referent被GC回收的事件。(如果對 ReferenceQueue作用和回調感興趣，可以先看最下面 ReferenceQueue 簡介)
另外，我們知道，GC在回收對象前會先調用對象自身的finalize()方法，如果它有實現的話，然后再清掉內存。而Phantom Reference的回調(enqueue)是在對象的finalize后，回收前觸發。這跟 WeakReference不一樣。WR是在回收后才通知的。在這個特殊的階段可以做一些特殊的clean操作。
RererenceQueue:
當一個 WeakReference 開始返回 null 時， 它所指向的對象已經準備被回收， 這時可以做一些合適的清理工作. 將一個 ReferenceQueue 傳給一個 Reference 的構造函數， 當對象被回收時， 虛擬機會自動將這個對象插入到 ReferenceQueue 中， WeakHashMap 就是利用 ReferenceQueue 來清除 key 已經沒有強引用的 entries.
public void testReferenceQueue() throws InterruptedException {
Object referent = new Object();
ReferenceQueue<Object> referenceQueue = new ReferenceQueue<Object>();
WeakReference<Object> weakReference = new WeakReference<Object>(referent, referenceQueue);
assertFalse(weakReference.isEnqueued());
Reference<? extends Object> polled = referenceQueue.poll();
assertNull(polled);
referent = null;
System.gc();
assertTrue(weakReference.isEnqueued());
Reference<? extends Object> removed = referenceQueue.remove();
assertNotNull(removed);
}
PhantomReference vs WeakReference
PhantomReference 有兩個好處， 其一， 它可以讓我們準確地知道對象何時被從內存中刪除， 這個特性可以被用于一些特殊的需求中(例如 Distributed GC， XWork 和 google-guice 中也使用 PhantomReference 做了一些清理性工作).
其二， 它可以避免 finalization 帶來的一些根本性問題, 上文提到 PhantomReference 的唯一作用就是跟蹤 referent 何時被 enqueue 到 ReferenceQueue 中, 但是 WeakReference 也有對應的功能, 兩者的區別到底在哪呢 ?
這就要說到 Object 的 finalize 方法, 此方法將在 gc 執行前被調用, 如果某個對象重載了 finalize 方法并故意在方法內創建本身的強引用, 這將導致這一輪的 GC 無法回收這個對象并有可能
引 起任意次 GC， 最后的結果就是明明 JVM 內有很多 Garbage 卻 OutOfMemory， 使用 PhantomReference 就可以避免這個問題， 因為 PhantomReference 是在 finalize 方法執行后回收的，也就意味著此時已經不可能拿到原來的引用, 也就不會出現上述問題, 當然這是一個很極端的例子, 一般不會出現.