java軟引用、弱引用、虛引用

時間 2019-11-16

標籤 java 引用欄目 Java 简体版

原文原文鏈接

一、概述html

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

下圖爲對象層次的引用算法

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

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

四、弱引用（WeakReference） 數組

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

五、虛引用（PhantomReference） 安全

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

六、相關應用app

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

如下程序建立了一個String對象、ReferenceQueue對象和WeakReference對象：

java代碼：

查看複製到剪貼板打印

//建立一個強引用
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"對象的引用：

java代碼：

查看複製到剪貼板打印

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(); //⑧

執行完以上第④行後，內存中引用與對象的關係如圖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顯示了執行完第⑧行後內存中引用與對象的關係。

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();
}
}

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

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

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對象的強引用。

java代碼：

查看複製到剪貼板打印

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);
}
}

程序輸出結果：

java代碼：

查看複製到剪貼板打印

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

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

看下面代碼:

java代碼：

查看複製到剪貼板打印

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

     此時，對於這個MyObject對象，有兩個引用路徑，一個是來自SoftReference對象的軟引用，一個來自變量aReference的強引用，因此這個MyObject對象是強可及對象。
    隨即，咱們能夠結束aReference對這個MyObject實例的強引用:
     aRef = null;
     此後，這個MyObject對象成爲了軟可及對象。若是垃圾收集線程進行內存垃圾收集，並不會由於有一個SoftReference對該對象的引用而始終保留該對象。Java虛擬機的垃圾收集線程對軟可及對象和其餘通常Java對象進行了區別對待:軟可及對象的清理是由垃圾收集線程根據其特定算法按照內存需求決定的。也就是說，垃圾收集線程會在虛擬機拋出OutOfMemoryError以前回收軟可及對象，並且虛擬機會盡量優先回收長時間閒置不用的軟可及對象，對那些剛剛構建的或剛剛使用過的「新」軟可反對象會被虛擬機儘量保留。在回收這些對象以前，咱們能夠經過:
     MyObject anotherRef=(MyObject)aSoftRef.get();
     從新得到對該實例的強引用。而回收以後，調用get()方法就只能獲得null了。

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

java代碼：

查看複製到剪貼板打印

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對象清除掉。經常使用的方式爲:

java代碼：

查看複製到剪貼板打印

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

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

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

java代碼：

查看複製到剪貼板打印

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對象進行緩存的緩存器的定義:

java代碼：

查看複製到剪貼板打印

import java.lang.ref.ReferenceQueue;
import java.lang.ref.SoftReference;
import java.util.Hashtable;
public class EmployeeCache {
static private EmployeeCache cache;// 一個Cache實例
private Hashtable employeeRefs;// 用於Cache內容的存儲
private ReferenceQueue q;// 垃圾Reference的隊列
// 繼承SoftReference，使得每個實例都具備可識別的標識。
// 而且該標識與其在HashMap內的key相同。
private class EmployeeRef extends SoftReference {
private String _key = "";
public EmployeeRef(Employee em, ReferenceQueue q) {
super(em, q);
_key = em.getID();
}
}
// 構建一個緩存器實例
private EmployeeCache() {
employeeRefs = new Hashtable();
q = new ReferenceQueue();
}
// 取得緩存器實例
public static 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);
}
}
// 清除Cache內的所有內容
public void clearCache() {
cleanCache();
employeeRefs.clear();
System.gc();
System.runFinalization();
}
}

8．使用弱引用構建非敏感數據的緩存
8.1全局 Map 形成的內存泄漏
無心識對象保留最多見的緣由是使用Map將元數據與臨時對象（transient object）相關聯。假定一個對象具備中等生命週期，比分配它的那個方法調用的生命週期長，可是比應用程序的生命週期短，如客戶機的套接字鏈接。須要將一些元數據與這個套接字關聯，如生成鏈接的用戶的標識。在建立Socket時是不知道這些信息的，而且不能將數據添加到Socket對象上，由於不能控制 Socket 類或者它的子類。這時，典型的方法就是在一個全局 Map 中存儲這些信息，以下面的 SocketManager 類所示：使用一個全局 Map 將元數據關聯到一個對象。

java代碼：

查看複製到剪貼板打印

public class SocketManager {
private Map<SOCKET,USER> m = new HashMap<SOCKET,USER>();
public void setUser(Socket s, User u) {
m.put(s, u);
}
public User getUser(Socket s) {
return m.get(s);
}
public void removeUser(Socket s) {
m.remove(s);
}
}

這種方法的問題是元數據的生命週期須要與套接字的生命週期掛鉤，可是除非準確地知道何時程序再也不須要這個套接字，並記住從 Map 中刪除相應的映射，不然，Socket 和 User 對象將會永遠留在 Map 中，遠遠超過響應了請求和關閉套接字的時間。這會阻止 Socket 和 User 對象被垃圾收集，即便應用程序不會再使用它們。這些對象留下來不受控制，很容易形成程序在長時間運行後內存爆滿。除了最簡單的狀況，在幾乎全部狀況下找出何時 Socket 再也不被程序使用是一件很煩人和容易出錯的任務，須要人工對內存進行管理。

     8.2如何使用WeakHashMap
     在Java集合中有一種特殊的Map類型—WeakHashMap，在這種Map中存放了鍵對象的弱引用，當一個鍵對象被垃圾回收器回收時，那麼相應的值對象的引用會從Map中刪除。WeakHashMap可以節約存儲空間，可用來緩存那些非必須存在的數據。關於Map接口的通常用法。
    下面示例中MapCache類的main()方法建立了一個WeakHashMap對象，它存放了一組Key對象的弱引用，此外main()方法還建立了一個數組對象，它存放了部分Key對象的強引用。

java代碼：

查看複製到剪貼板打印

import java.util.WeakHashMap;
class Element {
private String ident;
public Element(String id) {
ident = id;
}
public String toString() {
return ident;
}
public int hashCode() {
return ident.hashCode();
}
public boolean equals(Object obj) {
return obj instanceof Element && ident.equals(((Element) obj).ident);
}
protected void finalize(){
System.out.println("Finalizing "+getClass().getSimpleName()+" "+ident);
}
}
class Key extends Element{
public Key(String id){
super(id);
}
}
class Value extends Element{
public Value (String id){
super(id);
}
}
public class CanonicalMapping {
public static void main(String[] args){
int size=1000;
Key[] keys=new Key[size];
WeakHashMap map=new WeakHashMap();
for(int i=0;i< SPAN>
Key k=new Key(Integer.toString(i));
Value v=new Value(Integer.toString(i));
if(i%3==0)
keys[i]=k;
map.put(k, v);
}
System.gc();
}
}

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

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

java代碼：

查看複製到剪貼板打印

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);
}
}

8.4配合使用引用隊列 WeakHashMap 用弱引用承載映射鍵，這使得應用程序再也不使用鍵對象時它們能夠被垃圾收集，get() 實現能夠根據 WeakReference.get() 是否返回 null 來區分死的映射和活的映射。可是這只是防止 Map 的內存消耗在應用程序的生命週期中不斷增長所須要作的工做的一半，還須要作一些工做以便在鍵對象被收集後從 Map 中刪除死項。不然，Map 會充滿對應於死鍵的項。雖然這對於應用程序是不可見的，可是它仍然會形成應用程序耗盡內存。引用隊列是垃圾收集器嚮應用程序返回關於對象生命週期的信息的主要方法。弱引用有個構造函數取引用隊列做爲參數。若是用關聯的引用隊列建立弱引用，在弱引用對象成爲 GC 候選對象時，這個引用對象就在引用清除後加入到引用隊列中（具體參考上文軟引用示例）。 WeakHashMap 有一個名爲 expungeStaleEntries() 的私有方法，大多數 Map 操做中會調用它，它去掉引用隊列中全部失效的引用，並刪除關聯的映射。

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。