java對象的強引用，軟引用，弱引用和虛引用

1，雜談

在Java中，雖然不需要程序員手動去管理對象的生命周期，但是如果希望某些對象具備一定的生命周期的話（比如內存不足時JVM就會自動回收某些對象從而避免OutOfMemory的錯誤）就需要用到軟引用和弱引用了。

小編轉眼已經做開發很多年了，在帝都生活都快跟不上生活節奏了，伴隨物價、工作的變動幾乎沒2年都會搬家一次，日常用品也會越來越多搬家也就越來越麻煩，記得最近的一次搬家專門找了一輛金杯把里面都塞滿了，新家雖然比原來住的地方大了點，但是仍然空間有限啊。先說說開始准備搬家的時候先整理了一下內務（打包、清理垃圾）。

前一天把這些年的所有日常用品、生活用品都整理出來了，一些經常喜歡穿的衣服、鞋子啊雖然都買了很長時間了，還是把他們打包搬走了，搞不好明天就想穿上了。

再就是一些不知道什么時候可能被穿一次的衣服，真是取舍兩難啊，最后決定如果打包的箱子能裝下帶走，裝不下的話就當垃圾扔掉了。

還有一些長時間沒出現在我眼前的東東，直接被我垃圾扔掉了，再也不會使用了，占地方。

從JDK1.2版本開始，把對象的引用分為四種級別，從而使程序能更加靈活的控制對象的生命周期。這四種級別由高到低依次為：強引用、軟引用、弱引用和虛引用。Java中提供這四種引用類型主要有兩個目的：第一是可以讓程序員通過代碼的方式決定某些對象的生命周期；第二是有利於JVM進行垃圾回收。

2，詳解

1. 強引用
   我們使用的大部分引用其實都是強引用，這是在我們的開發工作當中普遍存在的。如果一個對象具有強引用，那就類似我們經常穿的衣服啊等必不可少的生活用品，我們肯定不會把他扔掉，同樣jvm的垃圾回收器也不會回收它。當內存空間不足的時候，java虛擬機寧可拋出OOM異常，也不會回收具有強引用的對象來釋放內存。我們可以將對象顯示的賦值為null，則gc認為該對象不存在引用，這時就可以回收這個對象。具體什么時候收集這要取決於gc的算法。也就是說方法的內部有一個強引用，這個引用保存在棧中，而真正的引用內容（Object）保存在堆中。當這個方法運行完成后就會退出方法棧，則引用內容的引用不存在，這個Object會被回收。 但是如果這個對象是全局的變量時，就需要在不用這個對象時賦值為null，因為強引用不會被垃圾回收。
   我們來看下Arraylist中的clear方法
   

   /**
        * Removes all of the elements from this list.  The list will
        * be empty after this call returns.
        */
       public void clear() {
           modCount++;
   
           // clear to let GC do its work
           for (int i = 0; i < size; i++)
               elementData[i] = null;
   
           size = 0;
       }

   這里看到Arraylist的clear方法其實是把整個list中的所有對象都賦值成了null，然后就等到GC回收了。

2. 軟引用
   軟引用是用來描述一些有用但並不是必需的對象，在Java中用java.lang.ref.SoftReference類來表示。對於軟引用關聯着的對象，只有在內存不足的時候JVM才會回收該對象。如果一個對象只有軟引用，就類似雞肋，食之無味、棄之可惜，如果內存空間足夠大，垃圾回收期就不會回收它，如果內存空間不夠了，就會回收這些對象。只有垃圾回收器沒有回收它，該對象就可以被程序使用。軟引用可用來實現內存敏感的高速緩存。
   軟引用可以和一個引用隊列（ReferenceQueue）聯合使用，如果軟引用所引用的對象被垃圾回收，java虛擬機會把這個軟引用加入到與之關聯的引用隊列中。
   

   String str=new String("abc");                                     // 強引用
   SoftReference<String> softRef=new SoftReference<String>(str);     // 軟引用x
   softRef.get() //得到str對象，如果str被回收，則返回null

   當內存不足時，等價於：   

   If(JVM.內存不足()) {
      str = null;  // 轉換為軟引用
      System.gc(); // 垃圾回收器進行回收
   }

    

3. 弱引用
   如果一個對象只有弱引用，那么就類似可有可無的生活用品，當JVM進行垃圾回收時，無論內存是否充足，都會回收被弱引用關聯的對象。在java中，用java.lang.ref.WeakReference類來表示。
   弱引用和軟引用的區別在於：弱引用的對象具有更短暫的生命周期。在垃圾回收時，一旦發現了只具有弱引用的對象，不管當前內存空間足夠與否，都會回收它的內存。不過，由於垃圾回收器是一個優先級很低的線程， 因此不一定會很快發現那些只具有弱引用的對象。 
   弱引用可以和一個引用隊列（ReferenceQueue）聯合使用，如果弱引用所引用的對象被垃圾回收，Java虛擬機就會把這個弱引用加入到與之關聯的引用隊列中。
   

   WeakReference<String> sr = new WeakReference<String>(new String("hello"));
   System.out.println(sr.get());
   System.gc();                //手工模擬JVM的gc進行垃圾回收
   System.out.println(sr.get());

   

   這說明只要JVM進行垃圾回收，被弱引用關聯的對象必定會被回收掉。

   public class ReferenceTest
   {
       private static ReferenceQueue<VeryBig> rq = new ReferenceQueue<VeryBig>();
       private static LinkedList<WeakReference<VeryBig>> linkedList = new LinkedList<WeakReference<VeryBig>>();
   
       public static void main(String args[])
       {
           int size = 3;
   
           for(int i = 0; i < size; i++)
           {
               linkedList.add(new VeryBigWeakReference(new VeryBig("Weak " + i), rq));
           }
           System.out.println("第一個VeryBig對象："+linkedList.getFirst().get());
           System.gc();
           try
           { // 下面休息幾分鍾，讓上面的垃圾回收線程運行完成
               TimeUnit.SECONDS.sleep(6);
           }
           catch(InterruptedException e)
           {
               e.printStackTrace();
           }
           checkQueue();
           System.out.println("第一個VeryBig對象："+linkedList.getFirst().get());
       }
   
       /**
        * @Description: 查看ReferenceQueue是否存在對象
        * @author J·K
        * @date 2018/6/8 11:36
   
        */
       public static void checkQueue()
       {
           Reference<? extends VeryBig> ref = null;
           while((ref = rq.poll()) != null)
           {
               if(ref != null)
               {
                   System.out.println("In queue: " + ((VeryBigWeakReference) (ref)).id);
               }
           }
       }
   }
   
   class VeryBig
   {
       public String id;
       byte[] b = new byte[2 * 1024];
   
       public VeryBig(String id)
       {
           this.id = id;
       }
   
       protected void finalize()
       {
           System.out.println("回收 VeryBig " + id);
       }
   }
   
   /**
    * @Description: 封裝WeakReference
    * @author J·K
    * @date 2018/6/8 11:37
   
    */
   class VeryBigWeakReference extends WeakReference<VeryBig>
   {
       public String id;
   
       public VeryBigWeakReference(VeryBig big, ReferenceQueue<VeryBig> rq)
       {
           super(big, rq);
           this.id = big.id;
       }
   
       protected void finalize()
       {
           System.out.println("回收 VeryBigWeakReference " + id);
       }
   }

   第一個VeryBig對象：com.VeryBig@1540e19d
   回收 VeryBig Weak 2
   回收 VeryBig Weak 1
   回收 VeryBig Weak 0
   In queue: Weak 1
   In queue: Weak 2
   In queue: Weak 0
   第一個VeryBig對象：null

    

4. 虛引用
   “虛引用”顧名思義，就是形同虛設，與其他幾種引用都不同，虛引用並不會決定對象的生命周期。在java中用java.lang.ref.PhantomReference類表示。如果一個對象僅持有虛引用，那么它就和沒有任何引用一樣，在任何時候都可能被垃圾回收。  虛引用主要用來跟蹤對象被垃圾回收的活動。虛引用與軟引用和弱引用的一個區別在於：虛引用必須和引用隊列（ReferenceQueue）聯合使用。當垃 圾回收器准備回收一個對象時，如果發現它還有虛引用，就會在回收對象的內存之前，把這個虛引用加入到與之關聯的引用隊列中。程序可以通過判斷引用隊列中是 否已經加入了虛引用，來了解被引用的對象是否將要被垃圾回收。程序如果發現某個虛引用已經被加入到引用隊列，那么就可以在所引用的對象的內存被回收之前采取必要的行動。
   垃圾回收時回收，無法通過引用取到對象值，可以通過如下代碼實現
   

           Object obj = new Object();
           ReferenceQueue<Object> rq = new ReferenceQueue<Object>();
           PhantomReference<Object> pf = new PhantomReference<Object>(obj,rq);
           obj=null;
           System.out.println(pf.get());//永遠返回null
           System.out.println(pf.isEnqueued());//返回是否從內存中已經刪除
           System.gc();
           TimeUnit.SECONDS.sleep(6);
           System.out.println(pf.isEnqueued());

   null
   false
   true

 3，總結