Java強引用、 軟引用、 弱引用、虛引用 – JAVA編程語言程序開發技術文章

1、對象的強、軟、弱和虛引用
    在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、對象可及性的判斷
    在很多時候,一個對象並不是從根集直接引用的,而是一個對象被其他對象引用,甚至同時被幾個對象所引用,從而構成一個以根集為頂的樹形結構。如圖2所示

    在這個樹形的引用鏈中,箭頭的方向代表瞭引用的方向,所指向的對象是被引用對象。由圖可以看出,從根集到一個對象可以由很多條路徑。比如到達對象5的路徑就有①-⑤,③-⑦兩條路徑。由此帶來瞭一個問題,那就是某個對象的可達性如何判斷:
單條引用路徑可達性判斷:在這條路徑中,最弱的一個引用決定對象的可達性。
多條引用路徑可達性判斷:幾條路徑中,最強的一條的引用決定對象的可達性。
    比如,我們假設圖2中引用①和③為強引用,⑤為軟引用,⑦為弱引用,對於對象5按照這兩個判斷原則,路徑①-⑤取最弱的引用⑤,因此該路徑對對象5的引用為軟引用。同樣,③-⑦為弱引用。在這兩條路徑之間取最強的引用,於是對象5是一個軟可達對象。

3、使用軟引用構建敏感數據的緩存
3.1 為什麼需要使用軟引用
   首先,我們看一個雇員信息查詢系統的實例。我們將使用一個Java語言實現的雇員信息查詢系統查詢存儲在磁盤文件或者數據庫中的雇員人事檔案信息。作為一個用戶,我們完全有可能需要回頭去查看幾分鐘甚至幾秒鐘前查看過的雇員檔案信息(同樣,我們在瀏覽WEB頁面的時候也經常會使用“後退”按鈕)。這時我們通常會有兩種程序實現方式:一種是把過去查看過的雇員信息保存在內存中,每一個存儲瞭雇員檔案信息的Java對象的生命周期貫穿整個應用程序始終;另一種是當用戶開始查看其他雇員的檔案信息的時候,把存儲瞭當前所查看的雇員檔案信息的Java對象結束引用,使得垃圾收集線程可以回收其所占用的內存空間,當用戶再次需要瀏覽該雇員的檔案信息的時候,重新構建該雇員的信息。很顯然,第一種實現方法將造成大量的內存浪費,而第二種實現的缺陷在於即使垃圾收集線程還沒有進行垃圾收集,包含雇員檔案信息的對象仍然完好地保存在內存中,應用程序也要重新構建一個對象。我們知道,訪問磁盤文件、訪問網絡資源、查詢數據庫等操作都是影響應用程序執行性能的重要因素,如果能重新獲取那些尚未被回收的Java對象的引用,必將減少不必要的訪問,大大提高程序的運行速度。

 
3.2 如果使用軟引用
    SoftReference的特點是它的一個實例保存對一個Java對象的軟引用,該軟引用的存在不妨礙垃圾收集線程對該Java對象的回收。也就是說,一旦SoftReference保存瞭對一個Java對象的軟引用後,在垃圾線程對這個Java對象回收前,SoftReference類所提供的get()方法返回Java對象的強引用。另外,一旦垃圾線程回收該Java對象之後,get()方法將返回null。看下面代碼:
1
MyObject  aRef  =  new   MyObject();
2
SoftReference  aSoftRef = new  SoftReference( aRef );
    此時,對於這個MyObject對象,有兩個引用路徑,一個是來自SoftReference對象的軟引用,一個來自變量aRef的強引用,所以這個MyObject對象是強可及對象。
    隨即,我們可以結束aRef對這個MyObject實例的強引用:
1
aRef  =  null ;
    此後,這個MyObject對象成為瞭軟可達對象。如果垃圾收集線程進行內存垃圾收集,並不會因為有一個SoftReference對該對象的引用而始終保留該對象。Java虛擬機的垃圾收集線程對軟可達對象和其他一般Java對象進行瞭區別對待:軟可及對象的清理是由垃圾收集線程根據其特定算法按照內存需求決定的。也就是說,垃圾收集線程會在虛擬機拋出OutOfMemoryError之前回收軟可及對象,而且虛擬機會盡可能優先回收長時間閑置不用的軟可達對象,對那些剛剛構建的或剛剛使用過的軟可達對象會被虛擬機盡可能保留。在回收這些對象之前,我們可以通過:
1
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的構造方法,如:
1
ReferenceQueue  queue  =  new   ReferenceQueue();
2
SoftReference   ref = new   SoftReference( aMyObject ,  queue );
    那麼當這個SoftReference所軟引用的aMyOhject被垃圾收集器回收的同時,ref所強引用的SoftReference對象被列入ReferenceQueue。也就是說,ReferenceQueue中保存的對象是Reference對象,而且是已經失去瞭它所軟引用的對象的Reference對象。另外從ReferenceQueue這個名字也可以看出,它是一個隊列,當我們調用它的poll()方法的時候,如果這個隊列中不是空隊列,那麼將返回隊列前面的那個Reference對象。
    在任何時候,我們都可以調用ReferenceQueue的poll()方法來檢查是否有它所關心的非強可達對象被回收。如果隊列為空,將返回一個null,否則該方法返回隊列中前面的一個Reference對象。利用這個方法,我們可以檢查哪個SoftReference所軟引用的對象已經被回收。於是我們可以把這些失去所軟引用的對象的SoftReference對象清除掉。常用的方式為:
1
SoftReference ref =  null ;
2
while  ((ref = (SoftReference)q .poll()) !=  null ) {
3
     // 清除 ref
4
}
理解瞭ReferenceQueue的工作機制之後,我們就可以開始構造一個Java對象的高速緩存器瞭。
 
3.4通過軟可及對象重獲方法實現Java對象的高速緩存
    利用Java2平臺垃圾收集機制的特性以及前述的垃圾對象重獲方法,我們通過一個雇員信息查詢系統的小例子來說明如何構建一種高速緩存器來避免重復構建同一個對象帶來的性能損失。我們將一個雇員的檔案信息定義為一個Employee類:
01
public   class  Employee {
02
     private  String  id ; // 雇員的標識號碼
03
     private  String  name ; // 雇員姓名
04
     private  String  department ; // 該雇員所在部門
05
     private  String  Phone ; // 該雇員聯系電話
06
     private   int   salary ; // 該雇員薪資
07
     private  String  origin ; // 該雇員信息的來源
08
 
09
     // 構造方法
10
     public  Employee(String id) {
11
        this . id  = id;
12
       getDataFromlnfoCenter();
13
    }
14
 
15
     // 到數據庫中取得雇員信息
16
     private   void  getDataFromlnfoCenter() {
17
        // 和數據庫建立連接井查詢該雇員的信息,將查詢結果賦值
18
        // 給 name, department, plone, salary等變量
19
        // 同時將 origin賦值為 "From DataBase"
20
    }
21
……
22
}
這個Employee類的構造方法中我們可以預見,如果每次需要查詢一個雇員的信息。哪怕是幾秒中之前剛剛查詢過的,都要重新構建一個實例,這是需要消耗很多時間的。下面是一個對Employee對象進行緩存的緩存器的定義:
 
01
import  java.lang.ref.ReferenceQueue;
02
import  java.lang.ref.SoftReference;
03
import  java.util.Hashtable;
04
 
05
public   class  EmployeeCache {
06
     static  private  EmployeeCache  cache ; // 一個 Cache實例
07
     private  Hashtable<String, EmployeeRef>  employeeRefs ; // 用於 Chche內容的存儲
08
     private  ReferenceQueue<Employee>  q ; // 垃圾 Reference的隊列
09
 
10
     // 繼承 SoftReference,使得每一個實例都具有可識別的標識,
11
     // 並且該標識與其在 HashMap內的 key相同。
12
     private class EmployeeRef extends SoftReference<Employee> {
13
        private  String  _key  =  "" ;
14
 
15
        public  EmployeeRef(Employee em, ReferenceQueue<Employee> q) {
16
            super (em, q);
17
            _key  = em.getID();
18
       }
19
    }
20
 
21
     // 構建一個緩存器實例
22
     private  EmployeeCache() {
23
        employeeRefs  =  new  Hashtable<String,EmployeeRef>();
24
        q  =  new  ReferenceQueue<Employee>();
25
    }
26
 
27
     // 取得緩存器實例
28
     public   static synchronized EmployeeCache getInstance() {
29
       if  (cache == null){
30
            cache = new EmployeeCache();
31
       }
32
       return cache ;
33
    }
34
 
35
     // 以軟引用的方式對一個 Employee對象的實例進行引用並保存該引用
36
     private   void  cacheEmployee(Employee em) {
37
       cleanCache(); // 清除垃圾引用
38
       EmployeeRef ref =  new  EmployeeRef(em,  q );
39
        employeeRefs .put(em.getID(), ref);
40
    }
41
 
42
     // 依據所指定的 ID號,重新獲取相應 Employee對象的實例
43
     public  Employee getEmployee(String ID) {
44
       Employee em =  null ;
45
        // 緩存中是否有該 Employee實例的軟引用,如果有,從軟引用中取得。
46
        if  ( employeeRefs .containsKey(ID)) {
47
           EmployeeRef ref = (EmployeeRef)  employeeRefs .get(ID);
48
           em = (Employee) ref.get();
49
       }
50
        // 如果沒有軟引用,或者從軟引用中得到的實例是 null,重新構建一個實例,
51
        // 並保存對這個新建實例的軟引用
52
        if  (em ==  null ) {
53
           em =  new  Employee(ID);
54
           System. out .println( "Retrieve From EmployeeInfoCenter. ID="  + ID);
55
            this .cacheEmployee(em);
56
       }
57
        return  em;
58
    }
59
 
60
     // 清除那些所軟引用的 Employee對象已經被回收的 EmployeeRef對象
61
     private   void  cleanCache() {
62
       EmployeeRef ref =  null ;
63
        while  ((ref = (EmployeeRef)  q .poll()) !=  null ) {
64
            employeeRefs .remove(ref. _key );
65
       }
66
    }
67
}
作者:愛國者

發佈留言

發佈留言必須填寫的電子郵件地址不會公開。