以前學(xué)習(xí)強(qiáng)軟弱虛引用的時候，只是走馬觀花看看博客，并沒有自己寫代碼去實(shí)踐、去證明，導(dǎo)致每次看完后，過不了多久就忘了，后來下定決心，一定要自己敲敲代碼，這樣才能讓印象更加深刻，古人云：紙上得來終覺淺，絕知此事要躬行。

Java中的四種引用

Java中有四種引用類型：強(qiáng)引用、軟引用、弱引用、虛引用。

Java為什么要設(shè)計(jì)這四種引用

Java的內(nèi)存分配和內(nèi)存回收，都不需要程序員負(fù)責(zé)，都是由偉大的JVM去負(fù)責(zé)，一個對象是否可以被回收，主要看是否有引用指向此對象，說的專業(yè)點(diǎn)，叫可達(dá)性分析。

Java設(shè)計(jì)這四種引用的主要目的有兩個：

可以讓程序員通過代碼的方式來決定某個對象的生命周期；

有利用垃圾回收。

強(qiáng)引用

強(qiáng)引用在 java.lang.ref 中并沒有實(shí)際的對應(yīng)類型，但我們程序中，我們寫的代碼，99.9999%都是強(qiáng)引用：

Object o = new Object();

這種就是強(qiáng)引用了，是不是在代碼中隨處可見，最親切。

只要某個對象有強(qiáng)引用與之關(guān)聯(lián)，這個對象永遠(yuǎn)不會被回收，即使內(nèi)存不足，JVM寧愿拋出OOM，也不會去回收。

那么什么時候才可以被回收呢？當(dāng)強(qiáng)引用和對象之間的關(guān)聯(lián)被中斷了，就可以被回收了。

我們可以手動把關(guān)聯(lián)給中斷了，方法也特別簡單：

o = null;

我們可以手動調(diào)用GC，看看如果強(qiáng)引用和對象之間的關(guān)聯(lián)被中斷了，資源會不會被回收，為了更方便、更清楚的觀察到回收的情況，我們需要新寫一個類，然后重寫finalize方法，下面我們來進(jìn)行這個實(shí)驗(yàn)：

public classStudent{

? ? @Override? ? protectedvoidfinalize()throwsThrowable{

? ? ? ? System.out.println("Student 被回收了");

? ? }

}

publicstaticvoidmain(String[] args){

? ? ? ? Student student = new Student();

? ? ? ? student = null;

? ? ? ? System.gc();

}

運(yùn)行結(jié)果：

Student被回收了

可以很清楚的看到資源被回收了。

當(dāng)然，在實(shí)際開發(fā)中，千萬不要重寫finalize方法

在實(shí)際的開發(fā)中，看到有一些對象被手動賦值為NULL，很大可能就是為了“特意提醒”JVM這塊資源可以進(jìn)行垃圾回收了。

強(qiáng)引用有如下特點(diǎn)：

強(qiáng)引用可以直接訪問目標(biāo)對象

強(qiáng)引用(存在)指向的對象任何時候都不會被回收，JVM寧愿拋出OOM異常，也不會回收。

強(qiáng)引用可能會導(dǎo)致內(nèi)存泄漏

注意： 為了盡量避免內(nèi)存不足的情況，我們可以在變量sb使用后通過顯示的將變量sb置為null，來加速對象的回收。

解釋： 1. 內(nèi)存溢出(out of memory) 是指 程序在申請內(nèi)存時，沒有足夠的內(nèi)存空間供其使用，出現(xiàn) out of memory.

內(nèi)存泄漏(memory leak) 是指 程序申請內(nèi)存后，無法釋放已申請的內(nèi)存空間，這樣的泄漏積少成多，memory leak 會導(dǎo)致 out of memory .

軟引用

下面先來看看如何創(chuàng)建一個軟引用：

SoftReferencestudentSoftReference=new SoftReference(new Student());

軟引用就是把對象用SoftReference包裹一下，當(dāng)我們需要從軟引用對象獲得包裹的對象，只要get一下就可以了：

SoftReference<Student>studentSoftReference=new SoftReference<Student>(new Student());

? ? ? ? Student student = studentSoftReference.get();

? ? ? ? System.out.println(student);

軟引用有什么特點(diǎn)呢：

當(dāng)內(nèi)存不足，會觸發(fā)JVM的GC，如果GC后，內(nèi)存還是不足，就會把軟引用的包裹的對象給干掉，也就是只有在內(nèi)存不足，JVM才會回收該對象。

還是一樣的，必須做實(shí)驗(yàn)，才能加深印象：

SoftReference<byte[]> softReference = new SoftReference<byte[]>(new byte[1024*1024*10]);

? ? ? ? System.out.println(softReference.get());

? ? ? ? System.gc();

? ? ? ? System.out.println(softReference.get());

? ? ? ? byte[] bytes = new byte[1024 * 1024 * 10];

? ? ? ? System.out.println(softReference.get());

我定義了一個軟引用對象，里面包裹了byte[]，byte[]占用了10M，然后又創(chuàng)建了10Mbyte[]。

運(yùn)行程序，需要帶上一個參數(shù)：

-Xmx20M

代表最大堆內(nèi)存是20M。

運(yùn)行結(jié)果：

[B@11d7fff

[B@11d7fff

null

可以很清楚的看到手動完成GC后，軟引用對象包裹的byte[]還活的好好的，但是當(dāng)我們創(chuàng)建了一個10M的byte[]后，最大堆內(nèi)存不夠了，所以把軟引用對象包裹的byte[]給干掉了，如果不干掉，就會拋出OOM。

軟引用到底有什么用呢？比較適合用作緩存，當(dāng)內(nèi)存足夠，可以正常的拿到緩存，當(dāng)內(nèi)存不夠，就會先干掉緩存，不至于馬上拋出OOM。

軟引用也可以和一個引用隊(duì)列聯(lián)合使用，如果軟引用中的對象（obj）被回收，那么軟引用會被 JVM 加入關(guān)聯(lián)的引用隊(duì)列中。

ReferenceQueue<Object> queue = new ReferenceQueue<>();

Object obj = new Object();

SoftReference softRef = new SoftReference<Object>(obj,queue);

//刪除強(qiáng)引用

obj = null;

//調(diào)用gc

System.gc();

System.out.println("gc之后的值: " + softRef.get()); // 對象依然存在

//申請較大內(nèi)存使內(nèi)存空間使用率達(dá)到閾值，強(qiáng)迫gc

byte[] bytes = new byte[100 * 1024 * 1024];

//如果obj被回收，則軟引用會進(jìn)入引用隊(duì)列

Reference<?> reference = queue.remove();

if (reference != null){

? ? System.out.println("對象已被回收: "+ reference.get());? // 對象為null

}

引用隊(duì)列（ReferenceQueue）作用

Queue的意義在于我們在外部可以對queue中的引用進(jìn)行監(jiān)控，當(dāng)引用中的對象被回收后，我們可以對引用對象本身繼續(xù)做一些清理操作，因?yàn)槲覀円脤ο螅╯oftRef）也占有一定的資源。

弱引用

弱引用的使用和軟引用類似，只是關(guān)鍵字變成了WeakReference：

WeakReference<byte[]> weakReference = new WeakReference<byte[]>(new byte[1024*1024*10]);

? ? ? ? System.out.println(weakReference.get());

弱引用的特點(diǎn)是不管內(nèi)存是否足夠，只要發(fā)生GC，都會被回收：

WeakReference<byte[]> weakReference = new WeakReference<byte[]>(new byte[1]);

? ? ? ? System.out.println(weakReference.get());

? ? ? ? System.gc();

? ? ? ? System.out.println(weakReference.get());

運(yùn)行結(jié)果：

[B@11d7fff

null

可以很清楚的看到明明內(nèi)存還很充足，但是觸發(fā)了GC，資源還是被回收了。

弱引用在很多地方都有用到，比如ThreadLocal、WeakHashMap。

弱引用也可以和一個引用隊(duì)列聯(lián)合使用，如果弱引用中的對象（obj）被回收，那么軟引用會被 JVM 加入關(guān)聯(lián)的引用隊(duì)列中。

ReferenceQueue<Object> queue = new ReferenceQueue<>();

Object obj = new Object();

WeakReference weakRef = new WeakReference<Object>(obj,queue);

//刪除強(qiáng)引用

obj = null;

System.out.println("gc之后的值: " + weakRef.get()); // 對象依然存在

//調(diào)用gc

System.gc();

//如果obj被回收，則軟引用會進(jìn)入引用隊(duì)列

Reference<?> reference = queue.remove();

if (reference != null){

? ? System.out.println("對象已被回收: "+ reference.get());? // 對象為null

}

軟引用和弱引用都非常適合保存那些可有可無的緩存數(shù)據(jù)，當(dāng)內(nèi)存不足時，緩存數(shù)據(jù)被回收（再通過備選方案查詢），當(dāng)內(nèi)存充足時，也可以存在較長時間，起到加速的作用。

應(yīng)用

WeakHashMap

當(dāng)key只有弱引用時，GC發(fā)現(xiàn)后會自動清理鍵和值，作為簡單的緩存表解決方案。

ThreadLocal

ThreadLocal.ThreadLocalMap.Entry 繼承了弱引用，key為當(dāng)前線程實(shí)例，和WeakHashMap基本相同。

虛引用

虛引用又被稱為幻影引用，我們來看看它的使用：

ReferenceQueue queue = new ReferenceQueue();

? ? ? ? PhantomReference<byte[]> reference = new PhantomReference<byte[]>(new byte[1], queue);

? ? ? ? System.out.println(reference.get());

虛引用的使用和上面說的軟引用、弱引用的區(qū)別還是挺大的，我們先不管ReferenceQueue 是個什么鬼，直接來運(yùn)行：

null

竟然打印出了null，我們來看看get方法的源碼：

publicTget(){

? ? ? ? return null;

? ? }

這是幾個意思，竟然直接返回了null。

這就是虛引用特點(diǎn)之一了：無法通過虛引用來獲取對一個對象的真實(shí)引用。

那虛引用存在的意義是什么呢？這就要回到我們上面的代碼了，我們把代碼復(fù)制下，以免大家再次往上翻：

ReferenceQueue queue = new ReferenceQueue();

? ? ? ? PhantomReference<byte[]> reference = new PhantomReference<byte[]>(new byte[1], queue);

? ? ? ? System.out.println(reference.get());

創(chuàng)建虛引用對象，我們除了把包裹的對象傳了進(jìn)去，還傳了一個ReferenceQueue，從名字就可以看出它是一個隊(duì)列。

虛引用的特點(diǎn)之二就是 虛引用必須與ReferenceQueue一起使用，當(dāng)GC準(zhǔn)備回收一個對象，如果發(fā)現(xiàn)它還有虛引用，就會在回收之前，把這個虛引用加入到與之關(guān)聯(lián)的ReferenceQueue中。

我們來用代碼實(shí)踐下吧：

ReferenceQueue queue = new ReferenceQueue();

? ? ? ? List<byte[]> bytes = new ArrayList<>();

? ? ? ? PhantomReference<Student> reference = new PhantomReference<Student>(new Student(),queue);

? ? ? ? new Thread(() -> {

? ? ? ? ? ? for (int i = 0; i < 100;i++ ) {

? ? ? ? ? ? ? ? bytes.add(new byte[1024 * 1024]);

? ? ? ? ? ? }

? ? ? ? }).start();

? ? ? ? new Thread(() -> {

? ? ? ? ? ? while (true) {

? ? ? ? ? ? ? ? Reference poll = queue.poll();

? ? ? ? ? ? ? ? if (poll != null) {

? ? ? ? ? ? ? ? ? ? System.out.println("虛引用被回收了：" + poll);

? ? ? ? ? ? ? ? }

? ? ? ? ? ? }

? ? ? ? }).start();

? ? ? ? Scanner scanner = new Scanner(System.in);

? ? ? ? scanner.hasNext();

? ? }

運(yùn)行結(jié)果：

Student 被回收了

虛引用被回收了：java.lang.ref.PhantomReference@1ade6f1

我們簡單的分析下代碼：

第一個線程往集合里面塞數(shù)據(jù)，隨著數(shù)據(jù)越來越多，肯定會發(fā)生GC。

第二個線程死循環(huán)，從queue里面拿數(shù)據(jù)，如果拿出來的數(shù)據(jù)不是null，就打印出來。

從運(yùn)行結(jié)果可以看到：當(dāng)發(fā)生GC，虛引用就會被回收，并且會把回收的通知放到ReferenceQueue中。

虛引用有什么用呢？在NIO中，就運(yùn)用了虛引用管理堆外內(nèi)存。

以上內(nèi)容都是我自己的一些感想，分享出來歡迎大家指正，順便求一波關(guān)注，有問題或者需要學(xué)習(xí)資料的伙伴可以點(diǎn)擊Java學(xué)習(xí)分享群一起來聊天哦