強軟弱虛---強引用、軟引用、弱引用、虛引用

強軟弱虛---強引用、軟引用、弱引用、虛引用

博客出自：http://blog.csdn.net/liuxian13183

由於最近要研究大數據，流媒體問題，所以專門來研究下java的幾種引用

其被垃圾回收的優先級依次往下排：強引用、軟引用、弱引用、虛引用

以下內容皆作者摘抄總結如下，以饗讀者！網絡資料比較繁雜，故不一一列舉，感謝所有無私奉獻的人們！

1、概述

   在JDK1.2以前的版本中，當一個對象不被任何變量引用，那麼程序就無法再使用這個對象。也就是說，只有對象處於可觸及狀態，程序才能使用它。這 就像在日常生活中，從商店購買了某樣物品後，如果有用，就一直保留它，否則就把它扔到垃圾箱，由清潔工人收走。一般說來，如果物品已經被扔到垃圾箱，想再 把它撿回來使用就不可能了。
   但有時候情況並不這麼簡單，你可能會遇到類似雞肋一樣的物品，食之無味，棄之可惜。這種物品現在已經無用了，保留它會佔空間，但是立刻扔掉它也不划算，因 爲也許將來還會派用場。對於這樣的可有可無的物品，一種折衷的處理辦法是：如果家裏空間足夠，就先把它保留在家裏，如果家裏空間不夠，即使把家裏所有的垃 圾清除，還是無法容納那些必不可少的生活用品，那麼再扔掉這些可有可無的物品。
   從JDK1.2版本開始，把對象的引用分爲四種級別，從而使程序能更加靈活的控制對象的生命週期。這四種級別由高到低依次爲：強引用、軟引用、弱引用和虛引用。

 

下圖爲對象層次的引用

 

 

2、強引用
   平時我們編程的時候例如：Object object=new Object（）；那object就是一個強引用了。如果一個對象具有強引用，那就類似於必不可少的生活用品，垃圾回收器絕不會回收它。當內存空 間不足，Java虛擬機寧願拋出OutOfMemoryError錯誤，使程序異常終止，也不會靠隨意回收具有強引用的對象來解決內存不足問題。

 

3、軟引用（SoftReference）
   如果一個對象只具有軟引用，那就類似於可有可物的生活用品。如果內存空間足夠，垃圾回收器就不會回收它，如果內存空間不足了，就會回收這些對象的內存。只要垃圾回收器沒有回收它，該對象就可以被程序使用。軟引用可用來實現內存敏感的高速緩存。 軟引用可以和一個引用隊列（ReferenceQueue）聯合使用，如果軟引用所引用的對象被垃圾回收，Java虛擬機就會把這個軟引用加入到與之關聯的引用隊列中。

4、弱引用（WeakReference）   

   如果一個對象只具有弱引用，那就類似於可有可物的生活用品。弱引用與軟引用的區別在於：只具有弱引用的對象擁有更短暫的生命週期。在垃圾回收器線程掃描它 所管轄的內存區域的過程中，一旦發現了只具有弱引用的對象，不管當前內存空間足夠與否，都會回收它的內存。不過，由於垃圾回收器是一個優先級很低的線程， 因此不一定會很快發現那些只具有弱引用的對象。  弱引用可以和一個引用隊列（ReferenceQueue）聯合使用，如果弱引用所引用的對象被垃圾回收，Java虛擬機就會把這個弱引用加入到與之關聯的引用隊列中。 

 

 5、虛引用（PhantomReference）   

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

 

6、相關應用

  在java.lang.ref包中提供了三個類：SoftReference類、WeakReference類和PhantomReference類，它們分別代表軟引用、弱引用和虛引用。ReferenceQueue類表示引用隊列，它可以和這三種引用類聯合使用，以便跟蹤Java虛擬機回收所引用的對 象的活動。

以下程序創建了一個String對象、ReferenceQueue對象和WeakReference對象：

//創建一個強引用
String str = new String("hello");
//創建引用隊列;爲範型標記，表明隊列中存放String對象的引用ReferenceQueue;rq = new ReferenceQueue();
//創建一個弱引用，它引用"hello"對象，並且與rq引用隊列關聯//爲範型標記，表明WeakReference會弱引用String對象
WeakReference;wf = new WeakReference(str, rq);

以上程序代碼執行完畢，內存中引用與對象的關係如圖2所示

       圖2 "hello"對象同時具有強引用和弱引用

 

     在圖2中，帶實線的箭頭表示強引用，帶虛線的箭頭表示弱引用。從圖中可以看出，此時"hello"對象被str強引用，並且被一個WeakReference對象弱引用，因此"hello"對象不會被垃圾回收。

 

   在以下程序代碼中，把引用"hello"對象的str變量置爲null，然後再通過WeakReference弱引用的get()方法獲得"hello"對象的引用：

String str = new String("hello"); //①;
ReferenceQueue rq = new ReferenceQueue(); //②;
WeakReference;wf = new WeakReference(str, rq); //③
str=null; //④取消"hello"對象的強引用String str1=wf.get(); //⑤假如"hello"對象沒有被回收，str1引用"hello"對象
//假如"hello"對象沒有被回收，rq.poll()返回null
Reference ref=rq.poll(); //⑥

執行完以上第④行後，內存中引用與對象的關係如圖3所示，此 時"hello"對象僅僅具有弱引用，因此它有可能被垃圾回收。假如它還沒有被垃圾回收，那麼接下來在第⑤行執行wf.get()方法會返回 "hello"對象的引用，並且使得這個對象被str1強引用。再接下來在第⑥行執行rq.poll()方法會返回null，因爲此時引用隊列中沒有任何 引用。ReferenceQueue的poll()方法用於返回隊列中的引用，如果沒有則返回null。

     圖3 "hello"對象只具有弱引用

 

    在以下程序代碼中，執行完第④行後，"hello"對象僅僅具有弱引用。接下來兩次調用System.gc()方法，催促垃圾回收器工作，從而提高 "hello"對象被回收的可能性。假如"hello"對象被回收，那麼WeakReference對象的引用被加入到ReferenceQueue中， 接下來wf.get()方法返回null，並且rq.poll()方法返回WeakReference對象的引用。圖4顯示了執行完第⑧行後內存中引用與對象的關係。

String str = new String("hello"); //①
ReferenceQueue rq = new ReferenceQueue(); //②;
WeakReference wf = new WeakReference(str, rq); //③
str=null; //④
//兩次催促垃圾回收器工作，提高"hello"對象被回收的可能性
System.gc(); //⑤
System.gc(); //⑥
String str1=wf.get(); //⑦ 假如"hello"對象被回收，str1爲null
Reference ref=rq.poll(); //⑧

 

  圖4 "hello"對象被垃圾回收，弱引用被加入到引用隊列

 

    在以下代碼References類中，依次創建了10個軟引用、10個弱引用和10個虛引用，它們各自引用一個Grocery對象。從程序運 行時的打印結果可以看出，虛引用形同虛設，它所引用的對象隨時可能被垃圾回收，具有弱引用的對象擁有稍微長的生命週期，當垃圾回收器執行回收操作時，有可能被垃圾回收，具有軟引用的對象擁有較長的生命週期，但在Java虛擬機認爲內存不足的情況下，也會被垃圾回收。

在以下代碼References類中，依次創建了10個軟引用、10個弱引用和10個虛引用，它們各自引用一個Grocery對象。從程序運 行時的打印結果可以看出，虛引用形同虛設，它所引用的對象隨時可能被垃圾回收，具有弱引用的對象擁有稍微長的生命週期，當垃圾回收器執行回收操作時，有可能被垃圾回收，具有軟引用的對象擁有較長的生命週期，但在Java虛擬機認爲內存不足的情況下，也會被垃圾回收。

package test;

import java.lang.ref.*;
import java.util.*;

class Grocery {
    private static final int SIZE = 10000;
    // 屬性d使得每個Grocery對象佔用較多內存，有80K左右
    private double[] d = new double[SIZE];
    private String id;

    public Grocery(String id) {
        this.id = id;
    }

    public String toString() {
        return id;
    }

    public void finalize() {
        System.out.println("Finalizing " + id);
    }
}

public class References {
    private static ReferenceQueue rq = new ReferenceQueue();

    public static void checkQueue() {
        Reference inq = rq.poll();
        // 從隊列中取出一個引用
        if (inq != null)
            System.out.println("In queue: " + inq + " : " + inq.get());
    }

    public static void main(String[] args) {
        final int size = 10;
        // 創建10個Grocery對象以及10個軟引用
        Set sa = new HashSet();
        for (int i = 0; i < size; i++) {
            SoftReference ref = new SoftReference(new Grocery("soft" + i), rq);
            System.out.println("Just created soft: " + ref.get());
            sa.add(ref);
        }
        System.gc();
        checkQueue();
        System.out.println("---------------------------------------------------");
        // 創建10個Grocery對象以及10個弱引用
        Set wa = new HashSet();
        for (int i = 0; i < size; i++) {
            WeakReference ref = new WeakReference(new Grocery ("weak " + i), rq);
            System.out.println("Just created weak: " + ref.get());
            wa.add(ref);
        }
        System.gc();
        checkQueue();
        System.out.println("---------------------------------------------------");
        // 創建10個Grocery對象以及10個虛引用
        Set pa = new HashSet();
        for (int i = 0; i < size; i++) {
            PhantomReference ref =new PhantomReference(new Grocery("Phantom " + i), rq);
            System.out.println("Just created Phantom: " + ref.get());
            pa.add(ref);
        }
        System.gc();
        checkQueue();
    }
}

在Java集合中有一種特殊的Map類型：WeakHashMap， 在這種Map中存放了鍵對象的弱引用，當一個鍵對象被垃圾回收，那麼相應的值對象的引用會從Map中刪除。WeakHashMap能夠節約存儲空間，可用來緩存那些非必須存在的數據。

     以下代碼MapCache類的main()方法創建了一個WeakHashMap對象，它存放了一組Key對象的弱引用，此外main()方法還創建了一個數組對象，它存放了部分Key對象的強引用。

package test;

import java.util.*;
import java.lang.ref.*;

class Key {
    String id;

    public Key(String id) {
        this.id = id;
    }
    public String toString() {
        return id;
    }
    public int hashCode() {
        return id.hashCode();
    }
    public boolean equals(Object r) {
        return (r instanceof Key) && id.equals(((Key) r).id);
    }
    public void finalize() {
        System.out.println("Finalizing Key " + id);
    }
}
class Value {
    String id;
    public Value(String id) {
        this.id = id;
    }
    public String toString() {
        return id;
    }
    public void finalize() {
        System.out.println("Finalizing Value " + id);
    }
}

public class MapCache {
    public static void main(String[] args) throws Exception {
        int size = 1000;// 或者從命令行獲得size的大小
        if (args.length > 0)
            size = Integer.parseInt(args[0]);
        Key[] keys = new Key[size]; // 存放鍵對象的強引用
        WeakHashMap whm = new WeakHashMap();
        for (int i = 0; i < size; i++) {
            Key k = new Key(Integer.toString(i));
            Value v = new Value(Integer.toString(i));
            if (i % 3 == 0)
                keys[i] = k; // 使Key對象持有強引用
            whm.put(k, v); // 使Key對象持有弱引用
        }
        // 催促垃圾回收器工作
        System.gc();// 把CPU讓給垃圾回收器線程
        Thread.sleep(8000);
    }
}

打印結果：

Finalizing Key 137
Finalizing Key 368
Finalizing Key 415
Finalizing Key 470
Finalizing Key 514
Finalizing Key 557
Finalizing Key 601
Finalizing Key 643
Finalizing Key 686
Finalizing Key 730
Finalizing Key 775
Finalizing Key 817
Finalizing Key 862
Finalizing Key 907
Finalizing Key 952
Finalizing Key 995
Finalizing Key 998
Finalizing Key 997

  從打印結果可以看出，當執行System.gc()方法後，垃圾回收器只會回收那些僅僅持有弱引用的Key對象。id可以被3整數的Key對象持有強引用，因此不會被回收。

7、如果使用軟引用
    SoftReference的特點是它的一個實例保存對一個Java對象的軟引用，該軟引用的存在不妨礙垃圾收集線程對該Java對象的回收。也就是說，一旦SoftReference保存了對一個Java對象的軟引用後，在垃圾線程對這個Java對象回收前，SoftReference類所提供的get()方法返回Java對象的強引用。另外，一旦垃圾線程回收該Java對象之後，get()方法將返回null。

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

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

     隨即，我們可以結束aReference對這個MyObject實例的強引用:
     aRef = null; 

在回收這些對象之前，我們可以通過:
     MyObject anotherRef=(MyObject)aSoftRef.get(); 
     重新獲得對該實例的強引用。而回收之後，調用get()方法就只能得到null了。

清除SoftReference對象

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

     理解了ReferenceQueue的工作機制之後，我們就可以開始構造一個Java對象的高速緩存器了。
8、用 WeakHashMap 堵住泄漏

    在 SocketManager 中防止泄漏很容易，只要用 WeakHashMap 代替 HashMap 就行了。（這裏假定SocketManager不需要線程安全）。當映射的生命週期必須與鍵的生命週期聯繫在一起時，可以使用這種方法。用WeakHashMap修復 SocketManager。

public class SocketManager {
    private Map m = new WeakHashMap();

    public void setUser(Socket s, User u) {
        m.put(s, u);
    }
    public User getUser(Socket s) {
        return m.get(s);
    }
}