Java中的引用類型和使用場景詳細(xì)

更新時間：2021年10月08日 14:18:28 作者：Grey

這篇文章介紹的是Java中的引用類型和使用場景，主要內(nèi)容展開Java中的引用類型，有強(qiáng)引用、軟引用、弱引用、虛引用,需要的朋友可以參考一下

1、強(qiáng)引用

沒有引用指向這個對象，垃圾回收會回收

package git.snippets.juc;

import java.io.IOException;

public class NormalRef {
    public static void main(String[] args) throws IOException {
        M m = new M();
        m = null;
        System.gc();
        System.in.read();
    }
    static class M {
        M() {}
        @Override
        protected void finalize() throws Throwable {
            System.out.println("finalized");
        }
    }
}

2、軟引用

當(dāng)有一個對象被一個軟引用所指向的時候，只有系統(tǒng)內(nèi)存不夠用的時候，才會被回收，可以用做緩存（比如緩存大圖片）

示例如下代碼：注：執(zhí)行以下方法的時候，需要把VM options設(shè)置為 -Xms20M -Xmx20M 。

package git.snippets.juc;

import java.io.IOException;
import java.lang.ref.SoftReference;
import java.util.concurrent.TimeUnit;

/**
 * heap將裝不下，這時候系統(tǒng)會垃圾回收，先回收一次，如果不夠，會把軟引用干掉
 * 軟引用，適合做緩存
 * 示例需要把Vm options設(shè)置為:-Xms20M -Xmx20M
 */
public class SoftRef {
    public static void main(String[] args) throws IOException {
        SoftReference<byte[]> reference = new SoftReference<>(new byte[1024 * 1024 * 10]);
        System.out.println(reference.get());
        System.gc();
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(reference.get());
        byte[] bytes = new byte[1024 * 1024 * 10];
        System.out.println(reference.get());
        System.in.read();
    }
}

上述代碼在第一次執(zhí)行 System.out.println(reference.get()) 時候，由于堆的最大最小值都是 20M ，而我們分配的 byte 數(shù)組是 10M ，沒有超過最大堆內(nèi)存，所以執(zhí)行垃圾回收，軟引用不被回收，后續(xù)又調(diào)用了 byte[] bytes = new byte[1024 * 1024 * 10]; 再次分配了 10M 內(nèi)存，此時堆內(nèi)存已經(jīng)超過設(shè)置的最大值，會進(jìn)行回收，所以最后一步的 System.out.println(reference.get()); 無法 get 到數(shù)據(jù)。

3、弱引用

只要垃圾回收，就會回收。如果有一個強(qiáng)引用指向弱引用中的這個對象，如果這個強(qiáng)引用消失，這個對象就應(yīng)該被回收。一般用在容器里面。

代碼示例如下：

package git.snippets.juc;

import java.lang.ref.WeakReference;
import java.util.HashMap;
import java.util.concurrent.TimeUnit;

/**
 * 弱引用遭到gc就會回收
 * ThreadLocal應(yīng)用，緩存應(yīng)用，WeakHashMap
 */
public class WeakRef {
    public static void main(String[] args) {
        WeakReference<T> reference = new WeakReference<>(new T());
        System.out.println(reference.get());
        System.gc();
        System.out.println(reference.get());
    }
    static class T {
        T() {}
        @Override
        protected void finalize() {
            System.out.println("finalized");
        }
    }
}

如果執(zhí)行了一次 GC ， reference.get() 獲取到的值即為空。

4、弱引用的使用場景

弱引用的一個典型應(yīng)用場景就是 ThreadLocal ，以下是 ThreadLocal 的的簡要介紹

set方法：

public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }

get方法：

public T get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        return setInitialValue();
    }

ThreadLocalMap 是當(dāng)前線程的一個成員變量，所以，其他線程無法讀取當(dāng)前線程設(shè)置的 ThreadLocal 值。

ThreadLocal.ThreadLocalMap threadLocals = null;

ThreadLocal 的主要應(yīng)用場景

場景一：每個線程需要一個獨享的對象：假設(shè)有100個線程都需要用到 SimpleDateFormat 類來處理日期格式，如果共用一個 SimpleDateFormat ，就會出現(xiàn)線程安全問題，導(dǎo)致數(shù)據(jù)出錯，如果加鎖，就會降低性能，此時使用 ThreadLocal ，給每個線程保存一份自己的本地 SimpleDateFormat ，就可以同時保證線程安全和性能需求。

場景二：每個線程內(nèi)部保存全局變量，避免傳參麻煩：假設(shè)一個線程的作用是拿到前端用戶信息，逐層執(zhí)行 Service1 ， Service2 ， Service3 ， Service4 層的業(yè)務(wù)邏輯，其中每個業(yè)務(wù)層都會用到用戶信息，此時一個解決辦法就是將 User 信息對象作為參數(shù)層層傳遞，但是這樣會導(dǎo)致代碼冗余且不利于維護(hù)。此時可以將 User 信息對象放入當(dāng)前線程的 Threadlocal 中，就變成了全局變量，在每一層業(yè)務(wù)層中，需要使用的時候直接從 Threadlocal 中獲取即可。

場景三： Spring 的聲明式事務(wù)，數(shù)據(jù)庫連接寫在配置文件，多個方法可以支持一個完整的事務(wù)，保證多個方法是用的同一個數(shù)據(jù)庫連接（其實就是放在 ThreadLocal 里面）

了解了 ThreadLocal 簡要介紹以后，我們可以深入理解一下 ThreadLocal 的一個內(nèi)部原理，前面提到， ThreadLocal 的 set 方法實際上是往當(dāng)前線程的一個 threadLocals 表中插入一條記錄，而這個表中的記錄都存在一個 Entry 對象中，這個對象有一個key和一個value， key 就是當(dāng)前線程的 ThreadLocal 對象。

static class Entry extends WeakReference<ThreadLocal<?>> {
            /** The value associated with this ThreadLocal. */
            Object value;

            Entry(ThreadLocal<?> k, Object v) {
                super(k);
                value = v;
            }
        }

這個 Entry 對象繼承了 WeakReference , 且構(gòu)造函數(shù)調(diào)用了 super(k) , 所以 Entry 中的 key 是通過一個弱引用指向的 ThreadLocal ，所以，我們在主方法中調(diào)用

ThreadLocal<Object> tl = new ThreadLocal<>();

tl 是通過強(qiáng)引用指向這個 ThreadLocal 對象。

當(dāng)前線程的 threadLocalMap 中的 key 是通過弱引用指向 ThreadLocal 對象，這樣就可以保證，在 tl 指向空以后，這個 ThreadLocal 會被回收，否則，如果 threadLocalMap 中的 key 是強(qiáng)引用指向 ThreadLocal 對象話，這個 ThreadLocal 對象永遠(yuǎn)不會被回收。就會導(dǎo)致內(nèi)存泄漏。

但是，即便 key 用弱引用指向 ThreadLocal 對象， key 值被回收后， Entry 中的 value 值就無法被訪問到了，且 value 是通過強(qiáng)引用關(guān)聯(lián)，所以，也會導(dǎo)致內(nèi)存泄漏，所以，每次在 ThreadLocal 中的對象不用了，記得要調(diào)用 remove 方法，把對應(yīng)的 value 也給清掉。

5、虛引用

用于管理堆外內(nèi)存回收

虛引用關(guān)聯(lián)了一個對象，以及一個隊列，只要垃圾回收，虛引用就被回收，一旦虛引用被回收，虛引用會被裝到這個隊列，并會收到一個通知（如果有值入隊列，會得到一個通知）所以，如果想知道虛引用何時被回收，就只需要不斷監(jiān)控這個隊列是否有元素加入進(jìn)來了。

虛引用里面關(guān)聯(lián)的對象用get方法是無法獲取的。

import java.lang.ref.PhantomReference;
import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;
import java.util.LinkedList;
import java.util.List;

// 配置 -Xms20M -Xmx20M
public class PhantomRef {
    private static final List<Object> LIST = new LinkedList<>();
    private static final ReferenceQueue<P> QUEUE = new ReferenceQueue<>();


    public static void main(String[] args) {
        PhantomReference<P> phantomReference = new PhantomReference<>(new P(), QUEUE);
        new Thread(() -> {
            while (true) {
                LIST.add(new byte[1024 * 1024]);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    Thread.currentThread().interrupt();
                }
                System.out.println(phantomReference.get());
            }
        }).start();

        new Thread(() -> {
            while (true) {
                Reference<? extends P> poll = QUEUE.poll();
                if (poll != null) {
                    System.out.println("--- 虛引用對象被jvm回收了 ---- " + poll);
                }
            }
        }).start();

        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }

    static class P {
        @Override
        protected void finalize() throws Throwable {
            System.out.println("finalized");
        }
    }
}

6、虛引用的應(yīng)用場景

JDK的 NIO 包中有一個 DirectByteBuffer ，這個 buffer 指向的是堆外內(nèi)存，所以當(dāng)這個 buffer 設(shè)置為空的時候，Java的垃圾回收無法回收，所以，可以用虛引用來管理這個 buffer ，當(dāng)我們檢測到這個虛引用被垃圾回收器回收的時候，可以做出相應(yīng)的處理，去回收堆外內(nèi)存。

到此這篇關(guān)于Java中的引用類型和使用場景詳細(xì)的文章就介紹到這了,更多相關(guān)Java中的引用類型和使用場景內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: