主要講解軟引用和弱引用的概念以及引用佇列的用法，最後介紹了weakhashmap，關於自定義使用軟引用結合hashmap構建快取，可以看參考文章，以後有機會也會專門寫一篇介紹。

java中各種引用存活週期

強引用>軟引用>弱引用>虛引用。

• StrongReference-jvm記憶體不足時也不會回收，直至OOM。
• SoftReference-jvm進行垃圾回收，記憶體不足，避免OOM會對軟引用的物件進行回收。
• WeakReference-JVM進行垃圾回收時會回收弱引用，無論記憶體是否緊張。
• PhantomReference-任何時候都可能被回收。

軟引用和弱引用概念區分

Soft reference objects, which are cleared at the discretion of the garbage collector in response to memory demand. Soft references are most often used to implement memory-sensitive caches.
All soft references to softly-reachable objects are guaranteed to have been cleared before the virtual machine throws an OutOfMemoryError.

對於軟引用因為記憶體需求會被釋放。丟擲OOM之前確定所有軟引用被釋放。

Weak reference objects, which do not prevent their referents from being made finalizable, finalized, and then reclaimed. Weak references are most often used to implement canonicalizing mappings.

對於弱引用gc的時候一定會被釋放。

軟引用的使用

(使用系統去判斷釋放時機，而非快取演算法。)

軟引用示例

    public class SoftReferenceTest
    {

        /**
         * @param args
         */
        public static void main(String[] args)
        {
            //軟引用的利用，首先強引用構造軟引用，然後強引用放空，使用軟引用，軟引用為空時重新初始化物件，一種快取機制
            A a = new A();
            SoftReference<A> sa = new SoftReference<A>(a);
            a = null;

            System.out.println("use a --->");

            //具體使用a物件的時候利用如下程式碼
            if(sa != null)
            {
                a = (A)sa.get();
            }
            else
            {
                a = new A();
                sa = new SoftReference<A>(a);
            }

            //gc對軟引用的影響
            System.out.println("gc effect for softreference");
            System.out.println(sa.get());
            System.gc();
            System.out.println(sa.get()); //由於這裡的場景記憶體不緊張，所以不會回收

            //gc對弱引用的影響
            A b = new A();
            WeakReference<A> sb = new WeakReference<SoftReferenceTest.A>(b);
            b = null;
            System.out.println("gc effect for weakreference");
            System.out.println(sb.get());
            System.gc();
            System.out.println(sb.get());//得到的是null，上一句gc觸發垃圾回收，弱引用被釋放，呼叫finalize

        }

        public static class A
        {
            public A()
            {

            }

            @Override
            protected void finalize() throws Throwable
            {
                // TODO Auto-generated method stub
                super.finalize();
                System.out.println("finalize of A" + this.toString());
            }
        }
    }

/*
use a --->
gc effect for softreference
[email protected]
[email protected]
gc effect for weakreference
[email protected]
null
finalize of [email protected]
*/

注意,程式碼呼叫gc，對於system.gc()使得gc過程在此後一個不固定時間觸發，不一定是立即呼叫。同樣jvm不保證物件的finalize一定被呼叫，但是finalize方法只能被呼叫一次。

軟引用和引用佇列

引用佇列用於判斷軟引用是否失效以及釋放軟引用本身這個引用(強引用)。
當軟可及物件被回收之後，雖然這個SoftReference物件的get()方法返回null,但這個SoftReference物件已經不再具有存在的價值，需要一個適當的清除機制，避免大量SoftReference物件帶來的記憶體洩漏。如果在建立SoftReference物件的時候，使用了一個ReferenceQueue物件作為引數提供給SoftReference的構造方法，那麼軟引用被gc處理後，會將軟引用本身這個引用加入到referenceQueue中，通過佇列的poll方法可以查到對應物件被釋放掉的軟引用。

構造軟引用時引入引用佇列：

ReferenceQueue queue = new ReferenceQueue();
SoftReference ref=new SoftReference(aMyObject, queue);

通過引用佇列去看是否有被釋放的引用物件，此引用已經無效。

SoftReference ref = null;
while ((ref = q.poll()) != null) {
// 清除ref
}

WeakHashMap

一種hashmap，如果key不被引用，則此鍵值對被移除。

    import java.util.Map;
    import java.util.WeakHashMap;

    public class WeakHashMapDemo
    {

        private static Map<String, String> map;

        public static void main(String args[])
        {
            map = new WeakHashMap<String, String>();

            map.put(new String("Maine"), "Augusta");

            Runnable runner = new Runnable()
            {
                public void run()
                {
                    while (map.containsKey("Maine"))
                    {
                        try
                        {
                            Thread.sleep(500);
                        } catch (InterruptedException ignored)
                        {
                        }
                        System.out.println("Thread waiting");
                        System.gc();
                    }
                }
            };
            Thread t = new Thread(runner);
            t.start();
            System.out.println("Main waiting");
            try
            {
                t.join();
            } catch (InterruptedException ignored)
            {
            }
        }
    }
/**
 * output
 * Main waiting
 * Thread waiting
 */

map.put(new String(“Maine”), “Augusta”);
使用匿名引數，對於作為key的string沒有強引用指向它，根據weakhashmap的規則，gc的時候這個key對應的鍵值對被移除。
weakhashmap充分利用了weakreference的特性，使用弱引用來做鍵值。
關於weakhashmap的一段介紹

WeakHashMap is an implementation of the Map interface that stores only weak references to its keys. Storing only weak references allows a key-value pair to be garbage-collected when its key is no longer referenced outside of the WeakHashMap.

關於weakReference的一段介紹

Weak Reference − If the only references to an object are weak references, the garbage collector can reclaim the object’s memory at any time.it doesn’t have to wait until the system runs out of memory. Usually, it will be freed the next time the garbage collector runs.

參考文件