每種編程語言都有自己操作內存中元素的方式，例如在 C 和 C++ 里是通過指針，而在 Java 中則是通過“引用”。在 JDK.1.2 之后，Java 對引用的概念進行了擴充，將引用分為了：強引用（Strong Reference）、軟引用（Soft Reference）、弱引用（Weak Reference）、虛引用（Phantom Reference）4 種，這 4 種引用的強度依次減弱，今天這篇文章就簡單介紹一下這四種類型，并簡單說一下他們的使用場景。
1. 強引用（Strong Reference）
強引用類型，是我們最常講的一個類型，我們先看一個例子：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
|
package cn.bridgeli.demo.reference; /** * @author BridgeLi * @date 2021/2/26 10:02 */public class User { @Override protected void finalize() throws Throwable { super.finalize(); System.out.println("finalize"); } } package cn.bridgeli.demo.reference; import org.junit.Test; /** * @author BridgeLi * @date 2021/2/26 10:03 */public class StrongReferenceTest { @Test public void testStrongReference() { User user = new User(); user = null; System.gc(); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } }} |
我們都知道當一個實例對象具有強引用時，垃圾回收器不會回收該對象，當內存不足時，寧愿 OOM，也就是拋出 OutOfMemeryError 異常也不會回收強引用的對象，因為 JVM 認為強引用的對象是用戶正在使用的對象，它無法分辨出到底該回收哪個，強行回收有可能導致系統嚴重錯誤。但是當對象被賦值為 null 之后，會被回收，并且會執行對象的 finalize 函數，此時我們可以通過該函數拯救自己，但是有兩點需要注意一個是只能拯救一次，當再次被垃圾回收的時候就不能拯救了，另一個就是有事沒事千萬不要重寫次函數，本例只是為了說明問題重寫了此函數，如果在工作中誤重寫了此函數，可能會導致垃圾不能回收，最終 OOM，另外有熟悉 GC 的同學沒？猜一下我為什么要 sleep 一下？
2. 軟引用（Soft Reference）
在我剛學 Java 的時候，并不知道怎么使用軟引用，那時候只知道強引用，其實是通過 java.lang.ref.SoftReference 類來使用軟引用的，為了說明軟引用，我們先看一個例子：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
|
package cn.bridgeli.demo.reference; import org.junit.Test; import java.lang.ref.SoftReference; /** * @author BridgeLi * @date 2021/2/26 10:21 */public class SoftReferenceTest { @Test public void testSoftReference() { SoftReference<byte[]> softReference = new SoftReference<>(new byte[1024 * 1024 * 10]); System.out.println(softReference.get()); System.gc(); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(softReference.get()); byte[] bytes = new byte[1024 * 1024 * 12]; System.out.println(softReference.get()); }} |
除了通過 get 方法獲取我們的軟引用對象之外，運行結果和強引用類型并沒有什么區別是吧？結果和我們想的一樣，但是別著急，加一個啟動參數再試試：
|
1
|
-Xms20m -Xmx20m |
我們都知道，這兩個參數是控制 JVM 啟動的時候堆的最大值和最小值的，這里面我們設置的最大值和最小值都是 20M，按照強引用的邏輯，我們一共申請了 22M 的空間，應該 OOM 才對，事實證明并沒有，通過打印語句證明，我們的軟引用被回收了，所以軟引用的特點是：在內存足夠的時候，軟引用對象不會被垃圾回收器回收，只有在內存不足時，垃圾回收器則會回收軟引用對象，當然回收了軟引用對象之后仍然沒有足夠的內存，這時同樣會拋出內存溢出異常。
看了軟引用的特點，我們很容易想到軟引用的使用場景：緩存。記得剛工作的時候，有個同事給我說，他做 Android，有一個加載圖片的應用，特麻煩，會 OOM，其實使用軟引用應該很輕松的能解決這個問題。
3. 弱引用（Weak Reference）
弱引用是通過 java.lang.ref.WeakReference 類來實現的，同樣我們也先看一個例子：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
|
package cn.bridgeli.demo.reference; import org.junit.Test; import java.lang.ref.WeakReference; /** * @author BridgeLi * @date 2021/2/26 10:30 */public class WeakReferenceTest { @Test public void testWeakReference() { WeakReference<User> weakReference = new WeakReference<>(new User()); System.out.println(weakReference.get()); System.gc(); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(weakReference.get()); }} |
通過例子我們可以看到，弱引用是一種比軟引用更弱的引用類型：在系統 GC 時，只要發現弱引用，不管系統堆空間是否足夠，都會將對象進行回收。看到這里可能會有同學有疑問，GC 什么時候啟動，除了我們顯示調用外，我們并不能控制（其實就算我們顯示調用，GC 也可能不會立即執行），而且 GC 之后，弱引用立即被回收，引用不到了，那么這個類型有什么用呢？其實這個類型還真有大用，我們鼎鼎大名的 ThreadLocal 類就是借助于這個類實現的，所以當你使用 ThreadLocal 的時候，就已經在使用弱類型了，我之前曾經寫過關于 ThreadLocal 的文章，但是當時理解不是很準確，不過說明的例子是沒有問題的，所以還有一定的參考價值，后面看看啥時候有機會重寫一篇關于 ThreadLocal 的文章，詳細說說這個類。
另外除了 ThreadLocal 類外還有一個類值得說一下，那就是 java.util.WeakHashMap 類，見名知意，我們就可以猜到這個類的特點。同樣通過一個例子說明一下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
package cn.bridgeli.demo.reference; import org.junit.Test; import java.util.Map;import java.util.WeakHashMap; /** * @author BridgeLi * @date 2021/2/26 10:38 */public class WeakHashMapTest { @Test public void testWeakHashMap() { Map map = new WeakHashMap<String, Object>(); for (int i = 0; i < 10000; i++) { map.put("key" + i, new byte[i]); } // Map map = new HashMap<String, Object>();// for (int i = 0; i < 10000; i++) {// map.put("key" + i, new byte[i]);// } }} |
記得啟動的時候設置一下，設置一下啟動的時候堆的大小，不要設置太大，可以看出區別。
4. 虛引用（Phantom Reference）
通過前面的例子，我們可以看到引用強度是越來越弱的，所以虛引用是最弱的一種引用類型，到底有多弱呢，我們同樣通過一個例子來看，需要說明的是，虛引用是通過 java.lang.ref.PhantomReference 類實現的。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
|
package cn.bridgeli.demo.reference; import org.junit.Test; import java.lang.ref.PhantomReference;import java.lang.ref.Reference;import java.lang.ref.ReferenceQueue;import java.util.ArrayList;import java.util.List; /** * @author BridgeLi * @date 2021/2/26 11:05 */public class PhantomReferenceTest { ReferenceQueue referenceQueue = new ReferenceQueue(); List<Object> list = new ArrayList<>(); @Test public void testPhantomReference() { PhantomReference<Object> phantomReference = new PhantomReference<>(new Object(), referenceQueue); System.out.println(phantomReference.get()); new Thread(() -> { while (true) { Reference reference = referenceQueue.poll(); if (null != reference) { System.out.println("============ " + reference.hashCode() + " ============"); } } }).start(); new Thread(() -> { while (true) { list.add(new byte[1024 * 1024 * 10]); } }).start(); try { Thread.sleep(500); } catch (InterruptedException e) { e.printStackTrace(); } }} |
我們看到了是什么？雖然軟引用和弱引用也很弱，但是我們還是可以通過 get 方法獲取到我們的引用對象，但是虛引用卻不行，點進去看一下源碼，我們可以看到虛引用的 get 方法，直接返回 null，也就是我們直接拿不到虛引用對象，那么這個類型又有什么使用場景呢？其實這個類型就不是給我們普通程序員使用的，在 io、堆外內存中有使用，所以對于我們普通程序員來說，了解到存在這個類型，另外通過上面的例子，我們還可以看到：當垃圾回收器準備回收一個對象時，如果發現它還有虛引用，就會在垃圾回收后，銷毀這個對象，將這個虛引用加入引用隊列。程序可以通過判斷引用隊列中是否已經加入了虛引用，來了解被引用的對象是否將要被垃圾回收。那么我們就可以在程序中發現某個虛引用已經被加入到引用隊列，那么就可以在所引用的對象的內存被回收之前采取一些必要的行動。
以上就是詳解Java的引用類型及使用場景的詳細內容，更多關于Java 引用類型及使用場景的資料請關注服務器之家其它相關文章！
原文鏈接：http://www.bridgeli.cn/archives/697
