[轉]Java 強引用、軟引用、弱引用、虛引用

時間 2019-12-24

標籤 java 引用欄目 Java 简体版

原文原文鏈接

一、對象的強、軟、弱和虛引用

在JDK 1.2之前的版本中，若一個對象不被任何變量引用，那麼程序就沒法再使用這個對象。也就是說，只有對象處於可觸及（reachable）狀態，程序才能使用它。從JDK 1.2版本開始，把對象的引用分爲4種級別，從而使程序能更加靈活地控制對象的生命週期。這4種級別由高到低依次爲：強引用、軟引用、弱引用和虛引用。

圖1爲對象應用類層次

1)強引用（StrongReference）

強引用是使用最廣泛的引用。若是一個對象具備強引用，那垃圾回收器毫不會回收它。當內存空間不足，Java虛擬機寧願拋出OutOfMemoryError錯誤，使程序異常終止，也不會靠隨意回收具備強引用的對象來解決內存不足的問題。

2)軟引用（SoftReference）

若是一個對象只具備軟引用，則內存空間足夠，垃圾回收器就不會回收它；若是內存空間不足了，就會回收這些對象的內存。只要垃圾回收器沒有回收它，該對象就能夠被程序使用。軟引用可用來實現內存敏感的高速緩存（下文給出示例）。

軟引用能夠和一個引用隊列（ReferenceQueue）聯合使用，若是軟引用所引用的對象被垃圾回收器回收，Java虛擬機就會把這個軟引用加入到與之關聯的引用隊列中。

3) 弱引用（WeakReference）

弱引用與軟引用的區別在於：弱引用的對象擁有更短暫的生命週期。在垃圾回收器線程掃描它所管轄的內存區域的過程當中，一旦發現了只具備弱引用的對象，無論當前內存空間足夠與否，都會回收它的內存。不過，因爲垃圾回收器是一個優先級很低的線程，所以不必定會很快發現那些只具備弱引用的對象。

弱引用能夠和一個引用隊列（ReferenceQueue）聯合使用，若是弱引用所引用的對象被垃圾回收，Java虛擬機就會把這個弱引用加入到與之關聯的引用隊列中。

4)虛引用（PhantomReference）

「虛引用」顧名思義，就是形同虛設，與其餘幾種引用都不一樣，虛引用並不會決定對象的生命週期。若是一個對象僅持有虛引用，那麼它就和沒有任何引用同樣，在任什麼時候候均可能被垃圾回收器回收。

虛引用主要用來跟蹤對象被垃圾回收器回收的活動。虛引用與軟引用和弱引用的一個區別在於：虛引用必須和引用隊列（ReferenceQueue）聯合使用。當垃圾回收器準備回收一個對象時，若是發現它還有虛引用，就會在回收對象的內存以前，把這個虛引用加入到與之關聯的引用隊列中。

程序能夠經過判斷引用隊列中是否已經加入了虛引用，來了解被引用的對象是否將要被垃圾回收。若是程序發現某個虛引用已經被加入到引用隊列，那麼就能夠在所引用的對象的內存被回收以前採起必要的行動。

二、對象可及性的判斷

在不少時候，一個對象並非從根集直接引用的，而是一個對象被其餘對象引用，甚至同時被幾個對象所引用，從而構成一個以根集爲頂的樹形結構。如圖2所示

在這個樹形的引用鏈中，箭頭的方向表明了引用的方向，所指向的對象是被引用對象。由圖能夠看出，從根集到一個對象能夠由不少條路徑。好比到達對象5的路徑就有①-⑤，③-⑦兩條路徑。由此帶來了一個問題，那就是某個對象的可達性如何判斷:

單條引用路徑可達性判斷:在這條路徑中，最弱的一個引用決定對象的可達性。

多條引用路徑可達性判斷:幾條路徑中，最強的一條的引用決定對象的可達性。

好比，咱們假設圖2中引用①和③爲強引用，⑤爲軟引用，⑦爲弱引用，對於對象5按照這兩個判斷原則，路徑①-⑤取最弱的引用⑤，所以該路徑對對象5的引用爲軟引用。一樣，③-⑦爲弱引用。在這兩條路徑之間取最強的引用，因而對象5是一個軟可達對象。 java

三、使用軟引用構建敏感數據的緩存

3.1 爲何須要使用軟引用

首先，咱們看一個僱員信息查詢系統的實例。咱們將使用一個Java語言實現的僱員信息查詢系統查詢存儲在磁盤文件或者數據庫中的僱員人事檔案信息。做爲一個用戶，咱們徹底有可能須要回頭去查看幾分鐘甚至幾秒鐘前查看過的僱員檔案信息(一樣，咱們在瀏覽WEB頁面的時候也常常會使用「後退」按鈕)。這時咱們一般會有兩種程序實現方式:一種是把過去查看過的僱員信息保存在內存中，每個存儲了僱員檔案信息的Java對象的生命週期貫穿整個應用程序始終;另外一種是當用戶開始查看其餘僱員的檔案信息的時候，把存儲了當前所查看的僱員檔案信息的Java對象結束引用，使得垃圾收集線程能夠回收其所佔用的內存空間，當用戶再次須要瀏覽該僱員的檔案信息的時候，從新構建該僱員的信息。很顯然，第一種實現方法將形成大量的內存浪費，而第二種實現的缺陷在於即便垃圾收集線程尚未進行垃圾收集，包含僱員檔案信息的對象仍然無缺地保存在內存中，應用程序也要從新構建一個對象。咱們知道，訪問磁盤文件、訪問網絡資源、查詢數據庫等操做都是影響應用程序執行性能的重要因素，若是能從新獲取那些還沒有被回收的Java對象的引用，必將減小沒必要要的訪問，大大提升程序的運行速度。算法

3.2 若是使用軟引用

SoftReference的特色是它的一個實例保存對一個Java對象的軟引用，該軟引用的存在不妨礙垃圾收集線程對該Java對象的回收。也就是說，一旦SoftReference保存了對一個Java對象的軟引用後，在垃圾線程對這個Java對象回收前，SoftReference類所提供的get()方法返回Java對象的強引用。另外，一旦垃圾線程回收該Java對象以後，get()方法將返回null。看下面代碼:

MyObject  aRef  =  new   MyObject();
SoftReference  aSoftRef = new  SoftReference( aRef );

此時，對於這個MyObject對象，有兩個引用路徑，一個是來自SoftReference對象的軟引用，一個來自變量aRef的強引用，因此這個MyObject對象是強可及對象。

隨即，咱們能夠結束aRef對這個MyObject實例的強引用:

aRef  =  null ;

此後，這個MyObject對象成爲了軟可達對象。若是垃圾收集線程進行內存垃圾收集，並不會由於有一個SoftReference對該對象的引用而始終保留該對象。Java虛擬機的垃圾收集線程對軟可達對象和其餘通常Java對象進行了區別對待:軟可及對象的清理是由垃圾收集線程根據其特定算法按照內存需求決定的。也就是說，垃圾收集線程會在虛擬機拋出OutOfMemoryError以前回收軟可及對象，並且虛擬機會盡量優先回收長時間閒置不用的軟可達對象，對那些剛剛構建的或剛剛使用過的軟可達對象會被虛擬機儘量保留。在回收這些對象以前，咱們能夠經過:

MyObject  anotherRef =(MyObject) aSoftRef .get()

從新得到對該實例的強引用。而回收以後，調用get()方法就只能獲得null了。

3.3 使用ReferenceQueue清除失去了軟引用對象的SoftReference

做爲一個Java對象，SoftReference對象除了具備保存軟引用的特殊性以外，也具備Java對象的通常性。因此，當軟可及對象被回收以後，雖然這個SoftReference對象的get()方法返回null,但這個SoftReference對象已經再也不具備存在的價值，須要一個適當的清除機制，避免大量SoftReference對象帶來的內存泄漏。在java.lang.ref包裏還提供了ReferenceQueue。若是在建立SoftReference對象的時候，使用了一個ReferenceQueue對象做爲參數提供給SoftReference的構造方法，如:

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

那麼當這個SoftReference所軟引用的aMyOhject被垃圾收集器回收的同時，ref所強引用的SoftReference對象被列入ReferenceQueue。也就是說，ReferenceQueue中保存的對象是Reference對象，並且是已經失去了它所軟引用的對象的Reference對象。另外從ReferenceQueue這個名字也能夠看出，它是一個隊列，當咱們調用它的poll()方法的時候，若是這個隊列中不是空隊列，那麼將返回隊列前面的那個Reference對象。

在任什麼時候候，咱們均可以調用ReferenceQueue的poll()方法來檢查是否有它所關心的非強可達對象被回收。若是隊列爲空，將返回一個null,不然該方法返回隊列中前面的一個Reference對象。利用這個方法，咱們能夠檢查哪一個SoftReference所軟引用的對象已經被回收。因而咱們能夠把這些失去所軟引用的對象的SoftReference對象清除掉。經常使用的方式爲:

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

理解了ReferenceQueue的工做機制以後，咱們就能夠開始構造一個Java對象的高速緩存器了。

3.4經過軟可及對象重獲方法實現Java對象的高速緩存

利用Java2平臺垃圾收集機制的特性以及前述的垃圾對象重獲方法，咱們經過一個僱員信息查詢系統的小例子來講明如何構建一種高速緩存器來避免重複構建同一個對象帶來的性能損失。咱們將一個僱員的檔案信息定義爲一個Employee類:

public   class  Employee {
     private  String  id ; // 僱員的標識號碼
     private  String  name ; // 僱員姓名
     private  String  department ; // 該僱員所在部門
     private  String  Phone ; // 該僱員聯繫電話
     private   int   salary ; // 該僱員薪資
     private  String  origin ; // 該僱員信息的來源
 
     // 構造方法
     public  Employee(String id) {
        this . id  = id;
       getDataFromlnfoCenter();
    }
 
     // 到數據庫中取得僱員信息
     private   void  getDataFromlnfoCenter() {
        // 和數據庫創建鏈接井查詢該僱員的信息，將查詢結果賦值
        // 給 name， department， plone， salary等變量
        // 同時將 origin賦值爲 "From DataBase"
    }
……
}

這個Employee類的構造方法中咱們能夠預見，若是每次須要查詢一個僱員的信息。哪怕是幾秒中以前剛剛查詢過的，都要從新構建一個實例，這是須要消耗不少時間的。下面是一個對Employee對象進行緩存的緩存器的定義:

import  java.lang.ref.ReferenceQueue;
import  java.lang.ref.SoftReference;
import  java.util.Hashtable;

public   class  EmployeeCache {
     static  private  EmployeeCache  cache ; // 一個 Cache實例
     private  Hashtable<String, EmployeeRef>  employeeRefs ; // 用於 Chche內容的存儲
     private  ReferenceQueue<Employee>  q ; // 垃圾 Reference的隊列
 
     // 繼承 SoftReference，使得每個實例都具備可識別的標識,
     // 而且該標識與其在 HashMap內的 key相同。
     private class EmployeeRef extends SoftReference<Employee> {
        private  String  _key  =  "" ;
 
        public  EmployeeRef(Employee em, ReferenceQueue<Employee> q) {
            super (em, q);
            _key  = em.getID();
       }
    }
 
     // 構建一個緩存器實例
     private  EmployeeCache() {
        employeeRefs  =  new  Hashtable<String,EmployeeRef>();
        q  =  new  ReferenceQueue<Employee>();
    }
 
     // 取得緩存器實例
     public   static synchronized EmployeeCache getInstance() {
       if  (cache == null){
            cache = new EmployeeCache();
       }
       return cache ;
    }
 
     // 以軟引用的方式對一個 Employee對象的實例進行引用並保存該引用
     private   void  cacheEmployee(Employee em) {
       cleanCache(); // 清除垃圾引用
       EmployeeRef ref =  new  EmployeeRef(em,  q );
        employeeRefs .put(em.getID(), ref);
    }
 
     // 依據所指定的 ID號，從新獲取相應 Employee對象的實例
     public  Employee getEmployee(String ID) {
       Employee em =  null ;
        // 緩存中是否有該 Employee實例的軟引用，若是有，從軟引用中取得。
        if  ( employeeRefs .containsKey(ID)) {
           EmployeeRef ref = (EmployeeRef)  employeeRefs .get(ID);
           em = (Employee) ref.get();
       }
        // 若是沒有軟引用，或者從軟引用中獲得的實例是 null，從新構建一個實例，
        // 並保存對這個新建實例的軟引用
        if  (em ==  null ) {
           em =  new  Employee(ID);
           System. out .println( "Retrieve From EmployeeInfoCenter. ID="  + ID);
            this .cacheEmployee(em);
       }
        return  em;
    }
 
     // 清除那些所軟引用的 Employee對象已經被回收的 EmployeeRef對象
     private   void  cleanCache() {
       EmployeeRef ref =  null ;
        while  ((ref = (EmployeeRef)  q .poll()) !=  null ) {
            employeeRefs .remove(ref. _key );
       }
    }
}