並發編程之ThreadLocal

並發編程之ThreadLocal

前言

當多線程訪問共享可變數據時，涉及到線程間同步的問題，並不是所有時候，都要用到共享數據，所以就需要線程封閉出場了。

數據都被封閉在各自的線程之中，就不需要同步，這種通過將數據封閉在線程中而避免使用同步的技術稱為線程封閉。

本文主要介紹線程封閉中的其中一種體現：ThreadLocal，將會介紹什么是 ThreadLocal；從 ThreadLocal 源碼角度分析，最后介紹 ThreadLocal 的應用場景。

什么是ThreadLocal

ThreadLocal 是 Java 里一種特殊變量，它是一個線程級別變量，每個線程都有一個 ThreadLocal 就是每個線程都擁有了自己獨立的一個變量，競態條件被徹底消除了，在並發模式下是絕對安全的變量。

可以通過 ThreadLocal value = new ThreadLocal (); 來使用。

會自動在每一個線程上創建一個 T 的副本，副本之間彼此獨立，互不影響，可以用 ThreadLocal 存儲一些參數，以便在線程中多個方法中使用，用以代替方法傳參的做法。

下面通過例子來了解下 ThreadLocal：

@Slf4j
public class ThreadLocalUtil {

    /**
     * static 確保全局只有一個保存 String 對象的 ThreadLocal 實例
     * final 確保 ThreadLocal 實例不可更改 防止被意外改變 導致存入的值和取出的值不一致，並且還能防止 ThreadLocal 實例內存泄漏
     */
    private static final ThreadLocal<String> THREAD_LOCAL = new ThreadLocal<>();

    public static void main(String[] args) throws InterruptedException {
        // 主線程設置值
        THREAD_LOCAL.set("主線程值");
        String v = THREAD_LOCAL.get();
        log.info("線程pool-1-thread-1執行之前，" + Thread.currentThread().getName() + " 線程獲取到的值為：{}", v);
        ExecutorService executorService = Executors.newFixedThreadPool(1);
        executorService.submit(() -> {
            String s = THREAD_LOCAL.get();
            log.info(Thread.currentThread().getName() + " 線程獲取到的值為：{}", s);
            // 子線程設置值
            THREAD_LOCAL.set("子線程值");
            s = THREAD_LOCAL.get();
            log.info("重新設置值之后，" + Thread.currentThread().getName() + " 線程獲取到的值為：{}", s);
            log.info(Thread.currentThread().getName() + "線 程執行結束");
            THREAD_LOCAL.remove();
        });
        // 等待子線程執行結束
        Thread.sleep(1000L);
        v = THREAD_LOCAL.get();
        log.info("線程pool-1-thread-1執行之后，" + Thread.currentThread().getName() + " 線程獲取到的值為：{}", v);
        THREAD_LOCAL.remove();
    }

}

首先通過 static final 定義了一個 THREAD_LOCAL 變量，其中 static 是為了確保全局只有一個保存 String 對象的 ThreadLocal 實例；

final 確保 ThreadLocal 的實例不可更改，防止被意外改變，導致放入的值和取出來的不一致，另外還能防止 ThreadLocal 的內存泄漏。上面的例子是演示在不同的線程中獲取它會得到不同的結果，運行結果如下：

14:33:42.176 [main] INFO com.linkcld.redis.util.ThreadLocalUtil - 線程pool-1-thread-1執行之前，main 線程獲取到的值為：主線程值
14:33:42.307 [pool-1-thread-1] INFO com.linkcld.redis.util.ThreadLocalUtil - pool-1-thread-1 線程獲取到的值為：null
14:33:42.307 [pool-1-thread-1] INFO com.linkcld.redis.util.ThreadLocalUtil - 重新設置值之后，pool-1-thread-1 線程獲取到的值為：子線程值
14:33:42.307 [pool-1-thread-1] INFO com.linkcld.redis.util.ThreadLocalUtil - pool-1-thread-1線 程執行結束
14:33:43.307 [main] INFO com.linkcld.redis.util.ThreadLocalUtil - 線程pool-1-thread-1執行之后，main 線程獲取到的值為：主線程值

首先在 pool-1-thread-1 線程執行之前，先給 THREAD_LOCAL 設置為 主線程值，然后可以取到這個值，然后通過創建一個新的線程以后去取這個值，發現新線程取到的為 null，意外着這個變量在不同線程中取到的值是不同的，不同線程之間對於 ThreadLocal 會有對應的副本，接着在線程 pool-1-thread-1 中執行對 THREAD_LOCAL 的修改，將值改為 子線程值，可以發現線程 pool-1-thread-1 獲取的值變為了 子線程值，主線程依然會讀取到屬於它的副本數據 主線程值，這就是線程的封閉。

看到這里，我相信大家一定會好奇 ThreadLocal 是如何做到多個線程對同一對象 set 操作，但是 get 獲取的值還都是每個線程 set 的值呢，接下來就讓我們進入源碼解析環節：

ThreadLocal 源碼解析

首先看下 ThreadLocal 都有哪些重要屬性：

// 當前 ThreadLocal 的 hashCode 由 nextHashCode 計算得來的，用於計算當前 ThreadLocal 再 ThreadLocalMap 中的索引位置
private final int threadLocalHashCode = nextHashCode();
// 哈希魔數，主要與斐波那契散列法和黃金分割相關
private static final int HASH_INCREMENT = 0x61c88647;
// 返回計算出的hash值，其值為 i * HASH_INCREMENT，其中 i 代表調用次數
private static int nextHashCode() {
    return nextHashCode.getAndAdd(HASH_INCREMENT);
}
// 保證了一台機器上，每個 ThreadLocal 的 threadLocalHashCode 值是唯一的
rivate static AtomicInteger nextHashCode = new AtomicInteger();

其中的 HASH_INCREMENT 也不是隨便取的，它轉化為十進制是 1640531527，2654435769 轉換成 int 類型就是 -1640531527，2654435769 等於 (√5-1)/2 乘以 2 的 32 次方。(√5-1)/2 就是黃金分割數，近似為 0.618，也就是說 0x61c88647 理解為一個黃金分割數乘以 2 的 32 次方，它可以保證 nextHashCode 生成的哈希值，均勻的分布在 2 的冪次方上，且小於 2 的 32 次方。

下面用例子來證明下：

@Slf4j
public class ThreadLocalUtil2 {

    private static final int HASH_INCREMENT = 0x61c88647;

    public static void main(String[] args) {
        int n = 5;
        int max = 2 << (n - 1);
        for (int i = 0; i < max; i++) {
            System.out.print(i * HASH_INCREMENT & (max - 1));
            System.out.print(" ");
        }
    }

}

運行結果為：

0 7 14 21 28 3 10 17 24 31 6 13 20 27 2 9 16 23 30 5 12 19 26 1 8 15 22 29 4 11 18 25 

可以發現元素索引值完美的散列在數組當中，並沒有出現沖突。

ThreadLocalMap

除了上述屬性外，還有一個重要的屬性 ThreadLocalMap，ThreadLocalMap 是 ThreadLocal 的靜態內部類，當一個線程有多個 ThreadLocal 時，需要一個容器來管理多個 ThreadLocal，ThreadLocalMap 的作用就是管理線程中多個 ThreadLocal，源碼如下：

static class ThreadLocalMap {
    // 鍵值對的存儲結構
    static class Entry extends WeakReference<ThreadLocal<?>> {
        // ThreadLocal 對應的value值
        Object value;
        
        Entry(ThreadLocal<?> k, Object v) {
            // ThreadLocal 是弱引用的，當GC時會被回收掉，但是 value 不會被回收
            super(k);
            value = v;
        }
    }
    // 默認初始容量 16 必須是2的冪
    private static final int INITIAL_CAPACITY = 16;
    // 底層時 Entry 數組，根據需要進行擴容，數組的大小必須是 2 的冪
    private Entry[] table;
    // 數組的大小
    private int size = 0;
    // 數組的擴容閾值 默認是 0
    private int threshold;
    // 數組擴容閾值為 長度的 2/3
    private void setThreshold(int len) {
        threshold = len * 2 / 3;
    }

}

從源碼中看到 ThreadLocalMap 其實就是一個簡單的 Map 結構，底層是數組，有初始化大小，也有擴容閾值大小，數組的元素是 Entry，Entry 的 key 就是 ThreadLocal 的引用，value 是 ThreadLocal 的值。ThreadLocalMap 解決 hash 沖突的方式采用的是線性探測法，如果發生沖突會繼續尋找下一個空的位置。

這樣的就有可能會發生內存泄漏的問題，下面讓我們進行分析：

ThreadLocal 內存泄漏

ThreadLocal 在沒有外部強引用時，發生 GC 時會被回收，那么 ThreadLocalMap 中保存的 key 值就變成了 null，而 Entry 又被 threadLocalMap 對象引用，threadLocalMap 對象又被 Thread 對象所引用，那么當 Thread 一直不終結的話，value 對象就會一直存在於內存中，也就導致了內存泄漏，直至 Thread 被銷毀后，才會被回收。

那么如何避免內存泄漏呢？

在使用完 ThreadLocal 變量后，需要我們手動 remove 掉，防止 ThreadLocalMap 中 Entry 一直保持對 value 的強引用，導致 value 不能被回收，其中 remove 源碼如下所示：

public void remove() {
    ThreadLocalMap m = getMap(Thread.currentThread());
    if (m != null)
        m.remove(this);
}

remove 方法的時序圖如下所示：

remove 方法是先獲取到當前線程的 ThreadLocalMap，並且調用了它的 remove 方法，從 map 中清理當前 ThreadLocal 對象關聯的鍵值對，這樣 value 就可以被 GC 回收了。

那么 ThreadLocal 是如何實現線程隔離的呢？

ThreadLocal 的 set 方法

我們先去看下 ThreadLocal 的 set 方法，源碼如下：

// set 方法
public void set(T value) {
    // 獲取當前thread信息 
    Thread t = Thread.currentThread();
    // 獲取當前線程所在的 ThreadLocalMap
    ThreadLocalMap map = getMap(t);
    // map 不為空直接set值
    if (map != null)
        map.set(this, value);
    else
    // map 為空時，需要先創建 map
        createMap(t, value);
}

// 創建map，並保存值
void createMap(Thread t, T firstValue) {
    t.threadLocals = new ThreadLocalMap(this, firstValue);
}

set 方法的作用是把我們想要存儲的 value 給保存進去。set 方法的流程主要是：

• 先獲取到當前線程的引用
• 利用這個引用來獲取到 ThreadLocalMap
• 如果 map 為空，則去創建一個 ThreadLocalMap
• 如果 map 不為空，就利用 ThreadLocalMap 的 set 方法將 value 添加到 map 中

set 方法的時序圖如下所示：

其中 map 就是我們上面講到的 ThreadLocalMap，可以看到它是通過當前線程對象獲取到的 ThreadLocalMap，接下來我們看 getMap方法的源代碼：

ThreadLocalMap getMap(Thread t) {
    return t.threadLocals;
}

getMap 方法的作用主要是獲取當前線程內的 ThreadLocalMap 對象，原來這個 ThreadLocalMap 是線程的一個屬性，下面讓我們看看 Thread 中的相關代碼：

// ThreadLocalMap 是線程的一個屬性，所以可以保證在多線程環境下的線程安全
ThreadLocal.ThreadLocalMap threadLocals = null;

可以看出每個線程都有 ThreadLocalMap 對象，被命名為 threadLocals，默認為 null，所以每個線程的 ThreadLocals 都是隔離獨享的。

調用 ThreadLocalMap.set() 時，會把當前 threadLocal 對象作為 key，想要保存的對象作為 value，存入 map。

其中 ThreadLocalMap.set() 的源碼如下：

// ThreadLocalMap set 方法
private void set(ThreadLocal<?> key, Object value) {
    
    Entry[] tab = table;
    int len = tab.length;
    // 計算 key 在數組中的下標
    int i = key.threadLocalHashCode & (len-1);
    // 遍歷數組，找到 threadLocal 對象
    for (Entry e = tab[i]; e != null; e = tab[i = nextIndex(i, len)]) {
        // 獲取下標位置處的 ThreadLocal 對象
        ThreadLocal<?> k = e.get();
        // 鍵值 ThreadLocal 匹配成功的話，直接更新 map 對於下標的 value 值
        if (k == key) {
            e.value = value;
            return;
        }
        
        // 如果 key 不存在的話，說明 ThreadLocal 被GC清理了，直接替換掉 
        if (k == null) {
            // 替換 Entry 方法
            replaceStaleEntry(key, value, i);
            return;
        }
    }
    // 直接遇到了空槽也沒有匹配到ThreadLocal對象，那么在此空槽處保存ThreadLocal對象和value值
    tab[i] = new Entry(key, value);
    // 數組長度+1
    int sz = ++size;
    // 如果沒有卡槽需要清理並且數組長度 大於等於 數組長度的 2/3，數組需要擴容
    if (!cleanSomeSlots(i, sz) && sz >= threshold)
        // 擴容的過程就是對所有的 key 進行重新哈希的過程
        rehash();
}

// 判斷是否有卡槽需要清理的方法
private boolean cleanSomeSlots(int i, int n) {
    boolean removed = false;
    Entry[] tab = table;
    int len = tab.length;
    do {
        i = nextIndex(i, len);
        Entry e = tab[i];
        if (e != null && e.get() == null) {
            n = len;
            removed = true;
            // 清理卡槽的數據
            i = expungeStaleEntry(i);
        }
    } while ( (n >>>= 1) != 0);
    return removed;
}

相信到這里，大家應該對 Thread、ThreadLocal 以及 ThreadLocalMap 的關系有了進一步的理解，下圖為三者之間的關系：

ThreadLocal 的 get 方法

了解完 set 方法后，讓我們看下 get 方法，源碼如下：

// ThreadLocal get 方法
public T get() {
    // 獲取當前線程 
    Thread t = Thread.currentThread();
    // 獲取ThreadLocalMap 方法
    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;
        }
    }
    // 如果 map 為空的話，需要初始化 map 
    return setInitialValue();
}

// 初始化 map 方法，返回的值 null
private T setInitialValue() {
    T value = initialValue();
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
    return value;
}

get 方法的主要流程為：

• 先獲取到當前線程的引用
• 獲取當前線程內部的 ThreadLocalMap
• 如果 map 存在，則獲取當前 ThreadLocal 對應的 value 值
• 如果 map 不存在或者找不到 value 值，則調用 setInitialValue() 進行初始化

get 方法的時序圖如下所示：

其中每個 Thread 的 ThreadLocalMap 以 threadLocal 作為 key，保存自己線程的 value 副本，也就是保存在每個線程中，並沒有保存在 ThreadLocal 對象中。

其中 ThreadLocalMap.getEntry() 方法的源碼如下

private Entry getEntry(ThreadLocal<?> key) {
    int i = key.threadLocalHashCode & (table.length - 1);
    Entry e = table[i];
    if (e != null && e.get() == key)
        return e;
    else
        return getEntryAfterMiss(key, i, e);
}

ThreadLocalMap 的 resize 方法

當 ThreadLocalMap 中的 ThreadLocal 的個數超過容量閾值時，ThreadLocalMap 就要開始擴容了，我們一起來看下 resize 的源代碼：

// 當需要擴容的時候，需要重新哈希
private void rehash() {
    // 清除需要清理的卡槽
    expungeStaleEntries();

    // 使用較低的閾值進行加倍以避免磁滯。2/3 * size * 3/4 = 1/2 * size
    if (size >= threshold - threshold / 4)
        // 擴容
        resize();
}

// 擴容算法，數組容量 * 2
private void resize() {
    Entry[] oldTab = table;
    int oldLen = oldTab.length;
    // 新的數組長度 = 舊長度*2
    int newLen = oldLen * 2;
    Entry[] newTab = new Entry[newLen];
    int count = 0;
    // 將數據重新哈希之后放到新數組中
    for (int j = 0; j < oldLen; ++j) {
        Entry e = oldTab[j];
        if (e != null) {
            ThreadLocal<?> k = e.get();
            // 如果有需要清理的ThreadLocal，把value置空，方便GC回收
            if (k == null) {
                e.value = null; // Help the GC
            } else {
                int h = k.threadLocalHashCode & (newLen - 1);
                while (newTab[h] != null)
                    h = nextIndex(h, newLen);
                newTab[h] = e;
                count++;
            }
        }
    }
    // 設置新的擴容閾值
    setThreshold(newLen);
    size = count;
    table = newTab;
}

resize 方法主要是進行擴容，同時會將垃圾值標記方便 GC 回收，擴容后數組大小是原來數組的兩倍。

ThreadLocal 應用場景

ThreadLocal 的特性也導致了應用場景比較廣泛，主要的應用場景如下：

• 線程間數據隔離，各線程的 ThreadLocal 互不影響
• 方便同一個線程使用某一對象，避免不必要的參數傳遞
• 全鏈路追蹤中的 traceId 或者流程引擎中上下文的傳遞一般采用 ThreadLocal
• Spring 事務管理器采用了 ThreadLocal
• Spring MVC 的 RequestContextHolder 的實現使用了 ThreadLocal