[[351029]]

本文轉(zhuǎn)載自微信公眾號「小菜良記」，作者小菜良記。轉(zhuǎn)載本文請聯(lián)系小菜良記公眾號。 

ThreadLocal 簡介

概念ThreadLocal 類是用來提供線程內(nèi)部的局部變量。這種變量在多線程環(huán)境下訪問(get 和set 方法訪問)時能保證各個線程的變量相對獨立于其他線程內(nèi)的變量。ThreadLocal 實例通常來說都是 private static 類型的，用于關(guān)聯(lián)線程和上下文。

作用

• 傳遞數(shù)據(jù)

提供線程內(nèi)部的局部變量。可以通過 ThreadLocal 在同一線程，不同組件中傳遞公共變量。

• 線程并發(fā)

適用于多線程并發(fā)情況下。

• 線程隔離

每個線程的變量都是獨立的，不會相互影響。

ThreadLocal 實戰(zhàn)

1. 常見方法

• ThreadLocal ()

構(gòu)造方法，創(chuàng)建一個 ThreadLocal 對象

• void set (T value)

設(shè)置當(dāng)前線程綁定的局部變量

• T get ()

獲取當(dāng)前線程綁定的局部變量

• void remove ()

移除當(dāng)前線程綁定的局部變量

2. 為什么要使用 ThreadLocal

首先我們先看一組并發(fā)條件下的代碼場景：

@Data 
public class ThreadLocalTest { 
    private String name; 
 
    public static void main(String[] args) { 
        ThreadLocalTest tmp = new ThreadLocalTest(); 
        for (int i = 0; i < 4; i++) { 
            Thread thread = new Thread(() -> { 
                tmp.setName(Thread.currentThread().getName()); 
                System.out.println(Thread.currentThread().getName() + 
                                   "\t 拿到數(shù)據(jù)：" + tmp.getName()); 
            }); 
            thread.setName("Thread-" + i); 
            thread.start(); 
        } 
    } 
} 

我們理想中的代碼輸出結(jié)果應(yīng)該是這樣的：

/** OUTPUT **/ 
Thread-0  拿到數(shù)據(jù)：Thread-0 
Thread-1  拿到數(shù)據(jù)：Thread-1 
Thread-2  拿到數(shù)據(jù)：Thread-2 
Thread-3  拿到數(shù)據(jù)：Thread-3 

但是實際上輸出的結(jié)果卻是這樣的：

/** OUTPUT **/ 
Thread-0  拿到數(shù)據(jù)：Thread-1 
Thread-3  拿到數(shù)據(jù)：Thread-3 
Thread-1  拿到數(shù)據(jù)：Thread-1 
Thread-2  拿到數(shù)據(jù)：Thread-2 

順序亂了沒有關(guān)系，但是我們可以看到 Thread-0 這個線程拿到的值卻是 Thread-1

從結(jié)果中我們可以看出多個線程在訪問同一個變量的時候會出現(xiàn)異常，這是因為線程間的數(shù)據(jù)沒有隔離!

并發(fā)線程出現(xiàn)的問題?那加鎖不就完事了!這個時候你三下五除二的寫下了以下代碼：

@Data 
public class ThreadLocalTest { 
 
    private String name; 
 
    public static void main(String[] args) { 
        ThreadLocalTest tmp = new ThreadLocalTest(); 
        for (int i = 0; i < 4; i++) { 
            Thread thread = new Thread(() -> { 
                synchronized (tmp) { 
                    tmp.setName(Thread.currentThread().getName()); 
                    System.out.println(Thread.currentThread().getName()  
                                       + "\t" + tmp.getName()); 
                } 
            }); 
            thread.setName("Thread-" + i); 
            thread.start(); 
        } 
    } 
} 
/** OUTPUT **/ 
Thread-2 Thread-2 
Thread-3 Thread-3 
Thread-1 Thread-1 
Thread-0 Thread-0 

從結(jié)果上看，加鎖好像是解決了上述問題，但是 synchronized 常用于多線程數(shù)據(jù)共享的問題，而非多線程數(shù)據(jù)隔離的問題。這里使用 synchronized 雖然解決了問題，但是多少有些不合適，并且 synchronized 屬于重量級鎖，為了實現(xiàn)多線程數(shù)據(jù)隔離貿(mào)然的加上synchronized，也會影響到性能。

加鎖的方法也被否定了，那么該如何解決?不如用 ThreadLocal 牛刀小試一番：

public class ThreadLocalTest { 
 
    private static ThreadLocal<String> threadLocal = new ThreadLocal<>(); 
 
    public String getName() { 
        return threadLocal.get(); 
    } 
 
    public void setName(String name) { 
        threadLocal.set(name); 
    } 
 
    public static void main(String[] args) { 
        ThreadLocalTest tmp = new ThreadLocalTest(); 
        for (int i = 0; i < 4; i++) { 
            Thread thread = new Thread(() -> { 
                tmp.setName(Thread.currentThread().getName()); 
                System.out.println(Thread.currentThread().getName() +  
                                   "\t 拿到數(shù)據(jù)：" + tmp.getName()); 
            }); 
            thread.setName("Thread-" + i); 
            thread.start(); 
        } 
    } 
} 

在查看輸出結(jié)果之前，我們先來看看代碼發(fā)生了那些變化

首先多了一個 private static 修飾的 ThreadLocal ，然后在 setName 的時候，我們實際上是往 ThreadLocal 里面存數(shù)據(jù)，在 getName 的時候，我們是在 ThreadLocal 里面取數(shù)據(jù)。感覺操作上也是挺簡單的，但是這樣真的能做到線程間的數(shù)據(jù)隔離嗎，我們再來看一看結(jié)果：

/** OUTPUT **/ 
Thread-1  拿到數(shù)據(jù)：Thread-1 
Thread-2  拿到數(shù)據(jù)：Thread-2 
Thread-0  拿到數(shù)據(jù)：Thread-0 
Thread-3  拿到數(shù)據(jù)：Thread-3 

從結(jié)果上可以看到每個線程都能取到對應(yīng)的數(shù)據(jù)。ThreadLocal 也已經(jīng)解決了多線程之間數(shù)據(jù)隔離的問題。

那么我們來小結(jié)一下，為什么需要使用ThreadLocal，與 synchronized 的區(qū)別是什么

• synchronized

原理： 同步機制采用 "以時間換空間" 的方式，只提供了一份變量，讓不同線程排隊訪問

側(cè)重點： 多個線程之間同步訪問資源

• ThreadLocal

原理： ThreadLocal 采用 "以空間換時間" 的方式，為每個線程都提供了一份變量的副本，從而實現(xiàn)同時訪問而互不干擾

側(cè)重點： 多線程中讓每個線程之間的數(shù)據(jù)相互隔離

3. 內(nèi)部結(jié)構(gòu)

從上面的案例中我們可以看到 ThreadLocal 的兩個主要方法分別是 set() 和 get()

那我們不妨猜想一下，如果讓我們來設(shè)計 ThreadLocal ，我們該如何設(shè)計，是否會有這樣的想法：每個 ThreadLocal 都創(chuàng)建一個 Map，然后用線程作為 Map 的 key，要存儲的局部變量作為 Map 的 value ，這樣就能達到各個線程的局部變量隔離的效果。

這個想法也是沒錯的，早期的 ThreadLocal 便是這樣設(shè)計的，但是在 JDK 8 之后便更改了設(shè)計，如下：

設(shè)計過程：

1. 每個 Thread 線程內(nèi)部都有一個 ThreadLocalMap
2. ThreadLocalMap 中存儲著以 ThreadLocal 對象為 key ，線程變量為 value
3. Thread 內(nèi)部的 Map 是由 ThreadLocal 維護的，由 ThreadLocal 負責(zé)向 Map 設(shè)置和獲取線程的變量值
4. 對于不同的線程，每次獲取副本值時，別的線程并不能獲取到線程的副本值，這樣就會形成副本的隔離，互不干擾

注： 每個線程都要有自己的一個 map，但是這個類就是一個普通的 Java 類，并沒有實現(xiàn)Map 接口，但是具有類似 Map 類似的功能。

通過這樣實現(xiàn)看起來貌似會比之前我們猜想的更加復(fù)雜，這樣做的好處是什么呢?

• 每個 Map 存儲的 Entry 數(shù)量就會變少，因為之前的存儲數(shù)量由 Thread 的數(shù)量決定，現(xiàn)在是由 ThreadMap 的數(shù)量決定，在實際開發(fā)中，ThreadLocal 的數(shù)量要更少于Thread 的數(shù)量。
• 當(dāng) Thread 銷毀之后，對應(yīng)的 ThreadLocalMap 也會隨之銷毀，能減少內(nèi)存的使用

4. 源碼分析

首先我們先看 ThreadLocalMap 中有哪些成員：

如果你看過 HashMap 的源碼，肯定會覺得這幾個特別熟悉，其中：

• INITIAL_CAPACITY：初始容量，必須是 2 的整次冪
• table：存放數(shù)據(jù)的table
• size：數(shù)組中 entries 的個數(shù)，用于判斷 table 當(dāng)前使用量是否超過閾值
• threshold：進行擴容的閾值，表使用量大于它的時候會進行擴容

ThreadLocals

Thread 類中有個類型為 ThreadLocal.ThreadLocalMap 類型的變量 ThreadLocals ，這個就是用來保存每個線程的私有數(shù)據(jù)。

ThreadLocalMap

ThreadLocalMap是ThreadLocal的內(nèi)部類，每個數(shù)據(jù)用Entry保存，其中的Entry用一個鍵值對存儲，鍵為ThreadLocal的引用。

我們可以看到 Entry 繼承于WeakReference，這是因為如果是強引用，即使把ThreadLocal 設(shè)置為 null，GC 也不會回收，因為 ThreadLocalMap 對它有強引用。

在沒有手動刪除這個Entry以及CurrentThread依然運行的前提下，始終有強引用鏈threadRef -> currentThread -> threadLocalMap -> entry，Entry就不會被回收(Entry中包括了ThreadLocal實例和value)，導(dǎo)致Entry內(nèi)存泄漏。

那是不是就是說如果使用了弱引用，就不會造成內(nèi)存泄露 呢，這也是不正確的。

因為如果我們沒有手動刪除 Entry 的情況下，此時 Entry 中的 key == null，這個時候沒有任何強引用指向 threaLocal 實例，所以 threadLocal 就可以順利被 gc 回收，但是value 不會被回收，而這塊的 value 永遠不會被訪問到，因此會導(dǎo)致內(nèi)存泄露

接下來我們看下 ThreadLocalMap 的幾個核心方法：

set 方法

首先我們先看下源碼：

public void set(T value) { 
    // 獲取當(dāng)前線程對象 
    Thread t = Thread.currentThread(); 
    // 獲取此線程對象中維護的ThreadLocalMap對象 
    ThreadLocalMap map = getMap(t); 
    // 判斷map是否存在 
    if (map != null) 
        // 存在則調(diào)用map.set設(shè)置此實體entry 
        map.set(this, value); 
    else 
        // 如果當(dāng)前線程不存在ThreadLocalMap對象則調(diào)用createMap進行ThreadLocalMap對象的初始化 
        // 并將 t(當(dāng)前線程)和value(t對應(yīng)的值)作為第一個entry存放至ThreadLocalMap中 
        createMap(t, value); 
} 
 
ThreadLocalMap getMap(Thread t) { 
    return t.threadLocals; 
} 
 
void createMap(Thread t, T firstValue) { 
    //這里的this是調(diào)用此方法的threadLocal 
    t.threadLocals = new ThreadLocalMap(this, firstValue); 
} 

執(zhí)行流程：

• 首先獲取當(dāng)前線程，并根據(jù)當(dāng)前線程獲取一個 map
• 如果獲取的 map 不為空，則將參數(shù)設(shè)置到 map 中(當(dāng)前 ThreadLocal 的引用作為key )
• 如果 Map 為空，則給該線程創(chuàng)建 map ，并設(shè)置初始值

get 方法

源碼如下：

public T get() { 
    // 獲取當(dāng)前線程對象 
    Thread t = Thread.currentThread(); 
    // 獲取此線程對象中維護的ThreadLocalMap對象 
    ThreadLocalMap map = getMap(t); 
    // 如果此map存在 
    if (map != null) { 
        // 以當(dāng)前的ThreadLocal 為 key，調(diào)用getEntry獲取對應(yīng)的存儲實體e 
        ThreadLocalMap.Entry e = map.getEntry(this); 
        // 對e進行判空  
        if (e != null) { 
            @SuppressWarnings("unchecked") 
            // 獲取存儲實體 e 對應(yīng)的 value值 
            // 即為我們想要的當(dāng)前線程對應(yīng)此ThreadLocal的值 
            T result = (T)e.value; 
            return result; 
        } 
    } 
    return setInitialValue(); 
} 
 
private T setInitialValue() { 
    // 調(diào)用initialValue獲取初始化的值 
    // 此方法可以被子類重寫, 如果不重寫默認返回null 
    T value = initialValue(); 
    // 獲取當(dāng)前線程對象 
    Thread t = Thread.currentThread(); 
    // 獲取此線程對象中維護的ThreadLocalMap對象 
    ThreadLocalMap map = getMap(t); 
    // 判斷map是否存在 
    if (map != null) 
        // 存在則調(diào)用map.set設(shè)置此實體entry 
        map.set(this, value); 
    else 
        // 如果當(dāng)前線程不存在ThreadLocalMap對象則調(diào)用createMap進行ThreadLocalMap對象的初始化 
        // 并將 t(當(dāng)前線程)和value(t對應(yīng)的值)作為第一個entry存放至ThreadLocalMap中 
        createMap(t, value); 
    // 返回設(shè)置的值value 
    return value; 
} 

執(zhí)行流程：

• 首先獲取當(dāng)前線程，根據(jù)當(dāng)前線程獲取一個 map
• 如果獲取的 map 不為空，則在 map 中以 ThreadLocal 的引用作為 key 來在 map 中獲取對應(yīng)的 Entry entry ，否則跳轉(zhuǎn)到第四步
• 如果 Entry entry 不為空 ，則返回 entry.value ，否則跳轉(zhuǎn)到第四步
• map 為空或者 entry 為空，則通過 initialValue 函數(shù)獲取初始值 value ，然后用ThreadLocal 的引用和 value 作為 firstKey 和 firstValue 創(chuàng)建一個新的 map

remove 方法

源碼如下：

public void remove() { 
    // 獲取當(dāng)前線程對象中維護的ThreadLocalMap對象 
    ThreadLocalMap m = getMap(Thread.currentThread()); 
    // 如果此map存在 
    if (m != null) 
        // 存在則調(diào)用map.remove 
        m.remove(this); 
} 
// 以當(dāng)前ThreadLocal為key刪除對應(yīng)的實體entry 
private void remove(ThreadLocal<?> key) { 
    Entry[] tab = table; 
    int len = tab.length; 
    int i = key.threadLocalHashCode & (len-1); 
    for (Entry e = tab[i]; 
         e != null; 
         e = tab[i = nextIndex(i, len)]) { 
        if (e.get() == key) { 
            e.clear(); 
            expungeStaleEntry(i); 
            return; 
        } 
    } 
} 

執(zhí)行流程：

首先獲取當(dāng)前線程，并根據(jù)當(dāng)前線程獲取一個 map

如果獲得的map 不為空，則移除當(dāng)前 ThreadLocal 對象對應(yīng)的 entry

initialValue 方法

源碼如下：

protected T initialValue() { 
    return null; 
} 

在源碼中我們可以看到這個方法僅僅簡單的返回了 null ，這個方法是在線程第一次通過get () 方法訪問該線程的 ThreadLocal 時調(diào)用的，只有在線程先調(diào)用了 set () 方法才不會調(diào)用 initialValue () 方法，通常情況下，這個方法最多被調(diào)用一次。

如果們想要 ThreadLocal 線程局部變量有一個除 null 以外的初始值，那么就必須通過子類繼承 ThreadLocal 來重寫此方法，可以通過匿名內(nèi)部類實現(xiàn)。