詳解Java的引用類型及使用場景

每種編程語言都有自己操作內存中元素的方式,例如在 C 和 C++ 裡是通過指針,而在 Java 中則是通過“引用”。在 JDK.1.2 之後,Java 對引用的概念進行瞭擴充,將引用分為瞭:強引用(Strong Reference)、軟引用(Soft Reference)、弱引用(Weak Reference)、虛引用(Phantom Reference)4 種,這 4 種引用的強度依次減弱,今天這篇文章就簡單介紹一下這四種類型,並簡單說一下他們的使用場景。

1. 強引用(Strong Reference)

強引用類型,是我們最常講的一個類型,我們先看一個例子:

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 類來使用軟引用的,為瞭說明軟引用,我們先看一個例子:

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 方法獲取我們的軟引用對象之外,運行結果和強引用類型並沒有什麼區別是吧?結果和我們想的一樣,但是別著急,加一個啟動參數再試試:

-Xms20m -Xmx20m

我們都知道,這兩個參數是控制 JVM 啟動的時候堆的最大值和最小值的,這裡面我們設置的最大值和最小值都是 20M,按照強引用的邏輯,我們一共申請瞭 22M 的空間,應該 OOM 才對,事實證明並沒有,通過打印語句證明,我們的軟引用被回收瞭,所以軟引用的特點是:在內存足夠的時候,軟引用對象不會被垃圾回收器回收,隻有在內存不足時,垃圾回收器則會回收軟引用對象,當然回收瞭軟引用對象之後仍然沒有足夠的內存,這時同樣會拋出內存溢出異常。

看瞭軟引用的特點,我們很容易想到軟引用的使用場景:緩存。記得剛工作的時候,有個同事給我說,他做 Android,有一個加載圖片的應用,特麻煩,會 OOM,其實使用軟引用應該很輕松的能解決這個問題。

3. 弱引用(Weak Reference)

弱引用是通過 java.lang.ref.WeakReference 類來實現的,同樣我們也先看一個例子:

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 類,見名知意,我們就可以猜到這個類的特點。同樣通過一個例子說明一下:

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 類實現的。

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 引用類型及使用場景的資料請關註WalkonNet其它相關文章!