併發編程之ThreadLocal深刻理解

時間  2021-08-14
標籤 java git github 面試 數組 緩存 安全 markdown 數據結構 多線程 欄目 Java 简体版
原文   原文鏈接

點贊再看，養成習慣，公衆號搜一搜【一角錢技術】關注更多原創技術文章。本文 GitHub org_hejianhui/JavaStudy 已收錄，有個人系列文章。java

前言

在平常的開發中，咱們常常會遇到在當前運行線程中保存一些信息，而且各線程之間是隔離的，不會相互影響，不存在併發問題，經過這樣的方式來實現請求調用鏈中方法之間參數傳遞的解耦，提高代碼結構的穩定性等。Java ThreadLocal就是用於實現這一目標的。在學習以前咱們先帶着如下幾個問題：git

  1. ThreadLocal 是什麼?
  2. ThreadLocal 怎麼用?
  3. ThreadLocal 和線程同步機制相比較？
  4. ThreadLocal 是如何實現線程隔離的呢？
  5. ThreadLocal 如何避免內存泄漏呢？
  6. ThreadLocal 與 Thread、ThreadLocalMap 之間的關係？

如下分析均基於JDK1.8。github

什麼是ThreadLocal

ThreadLocal，不少地方叫作線程本地變量，也有些地方叫作線程本地存儲。面試

ThreadLocal爲變量在每一個線程中都建立了一個副本，那麼每一個線程能夠訪問本身內部的副本變量，這樣同時多個線程訪問該變量並不會彼此相互影響，所以他們使用的都是本身從內存中拷貝過來的變量的副本，這樣就不存在線程安全問題，也不會影響程序的執行性能。數組

注意：雖然ThreadLocal可以解決上面說的問題，可是因爲在每一個線程中都建立了副本，因此要考慮它對資源的消耗，好比內存的佔用會比不使用ThreadLocal要大。緩存

ThreadLocal 怎麼用

一般使用靜態的變量來維護ThreadLocal，如:安全

static ThreadLocal<String> sThreadLocal = new ThreadLocal<String>
複製代碼

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

經過一個例子來了解 ThreadLocal：數據結構

package com.niuh.threadlocal;

/** * <p> * ThreadLocal 示例 * </p> */
public class ThreadLocalDemo {
    /** * ThreadLocal變量，每一個線程都有一個副本，互不干擾 */
    public static final ThreadLocal<String> THREAD_LOCAL = new ThreadLocal<>();

    public static void main(String[] args) throws Exception {
        new ThreadLocalDemo().threadLocalTest();
    }

    public void threadLocalTest() throws Exception {
        // 主線程設置值
        THREAD_LOCAL.set("一角錢技術");
        String v = THREAD_LOCAL.get();
        System.out.println("Thread-0線程執行以前，" + Thread.currentThread().getName() + "線程取到的值：" + v);

        new Thread(new Runnable() {
            @Override
            public void run() {
                String v = THREAD_LOCAL.get();
                System.out.println(Thread.currentThread().getName() + "線程取到的值：" + v);
                // 設置 threadLocal
                THREAD_LOCAL.set("一角錢技術2020");
                v = THREAD_LOCAL.get();
                System.out.println("從新設置以後，" + Thread.currentThread().getName() + "線程取到的值爲：" + v);
                System.out.println(Thread.currentThread().getName() + "線程執行結束");
            }
        }).start();
        // 等待全部線程執行結束
        Thread.sleep(3000L);
        v = THREAD_LOCAL.get();
        System.out.println("Thread-0線程執行以後，" + Thread.currentThread().getName() + "線程取到的值：" + v);
    }
}
複製代碼

首先經過 static final 定義了一個 THREAD_LOCAL 變量，其中 static 是爲了確保全局只有一個保存 String 對象的 ThreadLocal 實例；final 確保 ThreadLocal 的實例不可更改，防止被意外改變，致使放入的值和取出來的不一致，另外還能防止 ThreadLocal 的內存泄漏。上面的例子是演示在不一樣的線程中獲取它會獲得不一樣的結果，運行結果以下：多線程

Thread-0線程執行以前，main線程取到的值：一角錢技術
Thread-0線程取到的值：null
從新設置以後，Thread-0線程取到的值爲：一角錢技術2020
Thread-0線程執行結束
Thread-0線程執行以後，main線程取到的值：一角錢技術
複製代碼
  • 首先在 Thread-0 線程執行以前，先給 THREAD_LOCAL 設置爲 一角錢技術，而後能夠取到這個值；
  • 而後經過建立一個新的線程之後去取這個值，發現新線程取到的爲 null，意味着這個變量在不一樣線程中取到的值是不一樣的，不一樣線程之間對於 ThreadLocal 會有對應的副本；
  • 接着在線程 Thread-0 中執行對 THREAD_LOCAL 的修改，將值改成 一角錢技術2020，能夠發現線程 Thread-0 獲取的值變爲了 一角錢技術2020，主線程依然會讀取到屬於它的副本數據 一角錢技術，這就是線程的封閉。

看到這裏，我相信你們必定會好奇 ThreadLocal 是如何作到多個線程對同一對象 set 操做，可是 get 獲取的值還都是每一個線程 set 的值呢。

ThreadLocal和線程同步機制相比較

ThreadLocal和線程同步機制都是爲了解決多線程中相同變量的訪問衝突問題。

在同步機制中，經過對象的鎖機制保證同一時間只有一個線程訪問變量。這時該變量是多個線程共享的，使用同步機制要求程序慎密地分析何時對變量進行讀寫，何時須要鎖定某個對象，何時釋放對象鎖等繁雜的問題，程序設計和編寫難度相對較大。

而ThreadLocal則從另外一個角度來解決多線程的併發訪問。ThreadLocal會爲每個線程提供一個獨立的變量副本，從而隔離了多個線程對數據的訪問衝突。由於每個線程都擁有本身的變量副本，從而也就沒有必要對該變量進行同步了。ThreadLocal提供了線程安全的共享對象，在編寫多線程代碼時，能夠把不安全的變量封裝進ThreadLocal。

總的來講，對於多線程資源共享的問題，同步機制採用了「以時間換空間」的方式，而ThreadLocal採用了「以空間換時間」的方式。前者僅提供一份變量，讓不一樣的線程排隊訪問，然後者爲每個線程都提供了一份變量，所以能夠同時訪問而互不影響。

ThreadLocal源碼解析

成員變量

// 當前 ThreadLocal 的 hashCode，由 nextHashCode() 計算而來
// 用於計算當前 ThreadLocal 在 ThreadLocalMap 中的索引位置
private final int threadLocalHashCode = nextHashCode();
// 哈希魔數，主要與斐波那契散列法以及黃金分割有關
private static final int HASH_INCREMENT = 0x61c88647;
// 返回計算出的下一個哈希值，其值爲 i * HASH_INCREMENT，其中 i 表明調用次數
private static int nextHashCode() {
    return nextHashCode.getAndAdd(HASH_INCREMENT);
}
// 保證了在一臺機器中每一個 ThreadLocal 的 threadLocalHashCode 是惟一的
private 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 次方。

下面是 javaspecialists 中一篇文章對它的介紹：

This number represents the golden ratio (sqrt(5)-1) times two to the power of 31 ((sqrt(5)-1) * (2^31)). The result is then a golden number, either 2654435769 or -1640531527.

下面用例子來證實下：

private static final int HASH_INCREMENT = 0x61c88647;

public static void main(String[] args) throws Exception {
    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 是 ThreadLocal 的靜態內部類，當一個線程有多個 ThreadLocal 時，須要一個容器來管理多個 ThreadLocal，ThreadLocalMap 的做用就是管理線程中多個 ThreadLocal。

ThreadLocalMap 其實就是一個簡單的 Map 結構，底層是數組，有初始化大小，也有擴容閾值大小，數組的元素是 Entry。

ThreadLocalMap的數據結構是一個用數組表示的環，數組長度必須是2的次冪，一樣經過hash方式肯定節點在數組中的下標（hash值是ThreadLocal的遞增變量，而不是hashcode值），對於hash衝突的狀況，採用線性探測法，直接將元素防止對應下標後面的下一個空閒單元。

ThreadLocalMap的key採用的是弱引用WeakReference，所以在使用過程當中還須要注意及時清理key已經被gc回收的節點，及時釋放無效空間。

關於弱引用能夠查看《Java基礎 ｜強引用、弱引用、軟引用、虛引用》

成員屬性

// 初始容量，必須爲 2 的冪
private static final int INITIAL_CAPACITY = 16;

// 存儲 ThreadLocal 的鍵值對實體數組，長度必須爲 2 的冪
private Entry[] table;

// ThreadLocalMap 元素數量
private int size = 0;

//擴容的閾值，默認是數組大小的三分之二
private int threshold; // Default to 0
複製代碼

Entry類

Entry是ThreadLocalMap的內部類，用來表示其中的節點，繼承了弱引用WeadReference類。

// 鍵值對實體的存儲結構
static class Entry extends WeakReference<ThreadLocal<?>> {
    // 當前線程關聯的 value，這個 value 並無用弱引用追蹤
    Object value;
    /** * 構造鍵值對 * * @param k k 做 key,做爲 key 的 ThreadLocal 會被包裝爲一個弱引用 * @param v v 做 value */		
    Entry(ThreadLocal<?> k, Object v) {
        super(k);
        value = v;
    }
}

複製代碼

Entry 的 key 就是 ThreadLocal 的引用，value 是 ThreadLocal 的值。同時，Entry也繼承WeakReference，因此說Entry所對應key（ThreadLocal實例）的引用是一個弱引用。

弱引用的對象擁有更短暫的生命週期。在垃圾回收器線程掃描它所管轄的內存區域的過程當中，一旦發現了只具備弱引用的對象，無論當前內存空間足夠與否，都會回收它的內存。不過，因爲垃圾回收器是一個優先級很低的線程，所以不必定會很快發現那些只具備弱引用的對象。

構造方法

ThreadLocalMap 提供了兩個構造方法：

  1. ThreadLocalMap#ThreadLocalMap(ThreadLocal<?>, Object)
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
    table = new Entry[INITIAL_CAPACITY];
    int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
    table[i] = new Entry(firstKey, firstValue);
    size = 1;
    setThreshold(INITIAL_CAPACITY);
}
複製代碼
  • 根據第一個節點的key和value初始化map。
  • 初始化數組，肯定節點在數組的下標，初始化table[i]，設置size和threshold。
  • 進行散列的hash值是ThreadLocal的threadLocalHashCode，遞增生成。
  1. ThreadLocalMap#ThreadLocalMap(ThreadLocalMap)
private ThreadLocalMap(ThreadLocalMap parentMap) {
    Entry[] parentTable = parentMap.table;
    int len = parentTable.length;
    setThreshold(len);
    table = new Entry[len];

    for (int j = 0; j < len; j++) {
        Entry e = parentTable[j];
        if (e != null) {
            @SuppressWarnings("unchecked")
            ThreadLocal<Object> key = (ThreadLocal<Object>) e.get();
            if (key != null) {
                Object value = key.childValue(e.value);
                Entry c = new Entry(key, value);
                int h = key.threadLocalHashCode & (len - 1);
                while (table[h] != null)
                    h = nextIndex(h, len);
                table[h] = c;
                size++;
            }
        }
    }
}
複製代碼

初始化數組和threshold，遍歷節點加入數組。

擦除機制

ThreadLocalMap中內部類Entry，繼承了WeakReference，其key值是弱引用類型，在沒有強引用時會被gc回收，所以ThreadLocalMap要及時對這部分過時節點進行擦除。

  1. ThreadLocalMap#expungeStaleEntry(int)
private int expungeStaleEntry(int staleSlot) {
    Entry[] tab = table;
    int len = tab.length;

    // expunge entry at staleSlot
    tab[staleSlot].value = null;
    tab[staleSlot] = null;
    size--;

    // Rehash until we encounter null
    Entry e;
    int i;
    for (i = nextIndex(staleSlot, len);
         (e = tab[i]) != null;
         i = nextIndex(i, len)) {
        ThreadLocal<?> k = e.get();
        if (k == null) {
            e.value = null;
            tab[i] = null;
            size--;
        } else {
            int h = k.threadLocalHashCode & (len - 1);
            if (h != i) {
                tab[i] = null;

                // Unlike Knuth 6.4 Algorithm R, we must scan until
                // null because multiple entries could have been stale.
                while (tab[h] != null)
                    h = nextIndex(h, len);
                tab[h] = e;
            }
        }
    }
    return i;
}
複製代碼

擦除staleSlot處的無效節點，同時掃描處於staleSlot + 1 – 下一個null節點之間的節點，對於過時節點進行擦除，有效節點rehash，判斷是否須要修改位置。

  1. ThreadLocalMap#expungeStaleEntries()
private void expungeStaleEntries() {
    Entry[] tab = table;
    int len = tab.length;
    for (int j = 0; j < len; j++) {
        Entry e = tab[j];
        if (e != null && e.get() == null)
            expungeStaleEntry(j);
    }
}
複製代碼

全量掃描擦除，遍歷數組中的全部節點，對於過時節點調用擦除方法expungeStaleEntry進行擦除。

  1. ThreadLocalMap#cleanSomeSlots(int i, int n)
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;
}
複製代碼

啓發式掃描擦除。從 i+1 開始掃描檢查，若是連續log n個單元不須要擦除則結束方法，不然找到一個過時節點，重置計數，將n置爲數組長度，從新開始新一輪的掃描。只有掃描過程當中有一個過時節點，則認爲擦除成功，返回true。

ThreadLocalMap#getEntry(ThreadLocal<?>)

/** * 返回 key 關聯的鍵值對實體 * * @param key threadLocal * @return */
private Entry getEntry(ThreadLocal<?> key) {
    int i = key.threadLocalHashCode & (table.length - 1);
    Entry e = table[i];
    // 若 e 不爲空，而且 e 的 ThreadLocal 的內存地址和 key 相同，直接返回
    if (e != null && e.get() == key) {
        return e;
    } else {
        // 碰撞查找，從 i 開始向後遍歷找到鍵值對實體
        return getEntryAfterMiss(key, i, e);
    }
}
複製代碼

咱們再來看一下getEntryAfterMiss方法：

private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
    Entry[] tab = table;
    int len = tab.length;

    while (e != null) {
        ThreadLocal<?> k = e.get();
        if (k == key)
            return e;
        if (k == null)
            expungeStaleEntry(i);
        else
            i = nextIndex(i, len);
        e = tab[i];
    }
    return null;
}
複製代碼

用於在查找節點時沒有直接命中的狀況下進行線性的碰撞查找，對照查找過程當中的過時節點，進行擦除。

ThreadLocalMap#remove(ThreadLocal<?>)

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;
        }
    }
}
複製代碼

根據key值移除節點。找到節點後不是簡單的將該節點置爲null，還須要調用擦除方法，否則該節點後面的hash衝突節點會沒法經過getEntry獲取到。

ThreadLocalMap#set(ThreadLocal<?>, Object)

調用set() 時，會把當前 threadLocal 對象做爲 key，想要保存的對象做爲 value，存入 map。用於增長或覆蓋節點，相似於Map接口的put方法。

/** * 在 map 中存儲鍵值對<key, value> * * @param key threadLocal * @param value 要設置的 value 值 */
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 是 null，說明 ThreadLocal 被清理了，直接替換掉
		if (k == null) {
			replaceStaleEntry(key, value, i);
			return;
		}
	}

	// 直到碰見了空槽也沒找到匹配的ThreadLocal對象，那麼在此空槽處安排ThreadLocal對象和緩存的value
	tab[i] = new Entry(key, value);
	int sz = ++size;
	// 進行啓發式擦除，節點數量大於閾值。若是右節點擦除成功，節點數量不可能大於閾值
	if (!cleanSomeSlots(i, sz) && sz >= threshold) {
		// 擴容的過程也是對全部的 key 從新哈希的過程
		rehash();
	}
}
複製代碼

咱們依次來看看調用的幾個方法：

  1. ThreadLocalMap#replaceStaleEntry(ThreadLocal<?>, Object, int)
private void replaceStaleEntry(ThreadLocal<?> key, Object value, int staleSlot) {
     Entry[] tab = table;
     int len = tab.length;
     Entry e;

     // Back up to check for prior stale entry in current run.
     // We clean out whole runs at a time to avoid continual
     // incremental rehashing due to garbage collector freeing
     // up refs in bunches (i.e., whenever the collector runs).
     int slotToExpunge = staleSlot;
     for (int i = prevIndex(staleSlot, len);
          (e = tab[i]) != null;
          i = prevIndex(i, len))
         if (e.get() == null)
             slotToExpunge = i;

     // Find either the key or trailing null slot of run, whichever
     // occurs first
     for (int i = nextIndex(staleSlot, len);
          (e = tab[i]) != null;
          i = nextIndex(i, len)) {
         ThreadLocal<?> k = e.get();

         // If we find key, then we need to swap it
         // with the stale entry to maintain hash table order.
         // The newly stale slot, or any other stale slot
         // encountered above it, can then be sent to expungeStaleEntry
         // to remove or rehash all of the other entries in run.
         if (k == key) {
             e.value = value;

             tab[i] = tab[staleSlot];
             tab[staleSlot] = e;

             // Start expunge at preceding stale entry if it exists
             if (slotToExpunge == staleSlot)
                 slotToExpunge = i;
             cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
             return;
         }

         // If we didn't find stale entry on backward scan, the
         // first stale entry seen while scanning for key is the
         // first still present in the run.
         if (k == null && slotToExpunge == staleSlot)
             slotToExpunge = i;
     }

     // If key not found, put new entry in stale slot
     tab[staleSlot].value = null;
     tab[staleSlot] = new Entry(key, value);

     // If there are any other stale entries in run, expunge them
     if (slotToExpunge != staleSlot)
         cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
 }
複製代碼

slotToExpunge 表示第一個過時節點

  • 從staleSlot向前掃描，掃描到第一個爲null的節點截止，若是中間有過時節點，記錄掃描過程當中遇到的最後一個過時節點的下標爲 slotToExpunge；
  • 從staleSlot向後掃描，掃描找到key值對應的節點或null節點截止：
    • 若是在 [從staleSlot向前掃描] 中沒有找到過時節點，須要本次掃描中遇到的第一個過時節點的下標記錄爲 slotToExpunge ；
    • 若是找到來 key值對應的節點，覆蓋後將該節點移到 staleSlot 處，並將該節點的原來的位置做爲過時節點處理；
    • 若是沒有找到節點，新建節點放置到 staleSlot 處。
  • 若是在兩次掃描中找到了過時節點，先對該節點進行擦除，並調用啓發式掃描擦除。

整體來講，假如 i 下標處的節點是 staleSlot 節點左邊離得最近的null節點，j 下標處的節點是 staleSlot 節點右邊離得最近的null節點，而且key值對應的節點做爲過時節點處理。

那麼該方法的功能就兩段：

  • 將 key、value 組成節點放到 staleSlot 處；
  • 若是在（i — j）的序列中掃描到了過時節點，那麼擦除該節點，並從該節點後的第一個null節點開始啓發式擦除。

之因此須要向前掃描，是爲了不在掃描過程當中對有效節點的rehash後出現由過時節點致使的hash衝突。

  1. ThreadLocalMap#rehash()
private void rehash() {
	expungeStaleEntries();

    // Use lower threshold for doubling to avoid hysteresis
	if (size >= threshold - threshold / 4)
		resize();
}
複製代碼

啓動全局掃描擦除，擦除後再次判斷是否須要擴容。之因此叫作rehash，能夠理解成在全局掃描中全部的有效節點都須要從新hash肯定位置。能夠看到，並非節點數量大於閾值後就會觸發擴容，只有全局掃描擦除後數量仍大於閾值的3/4（容量的1/2）纔會進行擴容。

  1. ThreadLocalMap#resize()
/** * 擴容，從新計算索引，標記垃圾值，方便 GC 回收 */
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();
            // 如有垃圾值，則標記清理該元素的引用，以便GC回收
			if (k == null) {
				e.value = null; // Help the GC
			} else {
                // 計算 ThreadLocal 在新數組中的位置
				int h = k.threadLocalHashCode & (newLen - 1);
                若是發生衝突，使用線性探測日後尋找合適的位置
				while (newTab[h] != null)
					h = nextIndex(h, newLen);
                    newTab[h] = e;
                    count++;
                }
            }
	}
	// 設置新的擴容閥值，爲數組成都的三分之二
	setThreshold(newLen);
	size = count;
	table = newTab;
}
複製代碼

創建新數組，容量爲原來的2倍，遍歷數組中的元素，將有效節點hash後放入新數組，設置threshold，size等屬性。

ThreadLocal的 remove 方法

remove 方法源碼以下所示：

/** * 清理當前 ThreadLocal 對象關聯的鍵值對 */
public void remove() {
	// 返回當前線程持有的 map
	ThreadLocalMap m = getMap(Thread.currentThread());
	if (m != null) {
		// 從 map 中清理當前 ThreadLocal 對象關聯的鍵值對
		m.remove(this);
	}
}
複製代碼

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

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

ThreadLocal的 set 方法

set 方法源碼以下：

/** * 爲當前 ThreadLocal 對象關聯 value 值 * * @param value 要存儲在此線程的線程副本的值 */
public void set(T value) {
	// 返回當前ThreadLocal所在的線程
	Thread t = Thread.currentThread();
	// 返回當前線程持有的map
	ThreadLocalMap map = getMap(t);
	if (map != null) {
		// 若是 ThreadLocalMap 不爲空，則直接存儲<ThreadLocal, T>鍵值對
		map.set(this, value);
	} else {
		// 不然，須要爲當前線程初始化 ThreadLocalMap，並存儲鍵值對 <this, firstValue>
		createMap(t, value);
	}
}
複製代碼

set 方法的做用是把咱們想要存儲的 value 給保存進去。其主要流程爲：

  1. 先獲取噹噹前線程的引用；
  2. 利用這個引用來獲取到 ThreadLocalMap；
  3. 若是 map 爲空，則去建立一個 ThreadLocalMap；
  4. 若是 map 不爲空，就利用 ThreadLocalMap 的 set 方法將 value 添加到 map 中。

其中 map 就是 ThreadLocalMap。

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

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

ThreadLocal的 getMap 方法

/** * 返回當前線程 thread 持有的 ThreadLocalMap * * @param t 當前線程 * @return ThreadLocalMap */
ThreadLocalMap getMap(Thread t) {
	return t.threadLocals;
}
複製代碼

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

/** * ThreadLocal 的 ThreadLocalMap 是線程的一個屬性，因此在多線程環境下 threadLocals 是線程安全的 */
ThreadLocal.ThreadLocalMap threadLocals = null;
複製代碼

ThreadLocal的 get 方法

get 方法源碼以下：

/** * 返回當前 ThreadLocal 對象關聯的值 * * @return */
public T get() {
	// 返回當前 ThreadLocal 所在的線程
	Thread t = Thread.currentThread();
	// 從線程中拿到 ThreadLocalMap
	ThreadLocalMap map = getMap(t);
	if (map != null) {
		// 從 map 中拿到 entry
		ThreadLocalMap.Entry e = map.getEntry(this);
		// 若是不爲空，讀取當前 ThreadLocal 中保存的值
		if (e != null) {
			@SuppressWarnings("unchecked")
			T result = (T) e.value;
			return result;
		}
	}
	// 若 map 爲空，則對當前線程的 ThreadLocal 進行初始化，最後返回當前的 ThreadLocal 對象關聯的初值，即 value
	return setInitialValue();
}
複製代碼

get 方法的主要流程爲：

  1. 先獲取到當前線程的引用；
  2. 獲取當前線程內部的 ThreadLocalMap；
  3. 若是 map 存在，則獲取當前 ThreadLocal 對應的 value 值；
  4. 若是 map 不存在或者找不到 value 值，則調用 setInitialValue() 進行初始化。

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

其中每一個 Thread 的 ThreadLocalMap 以 threadLocal 做爲 key，保存本身的線程的 value 副本，也就是保存在每一個線程中，並無保存在 ThreadLocal 對象中。

小結

經過對源碼的分析，如今咱們來總結一下：

  1. 每一個Thread維護着一個ThreadLocalMap的引用；
  2. ThreadLocalMap是ThreadLocal的內部類，用Entry來進行存儲；
  3. ThreadLocal建立的副本是存儲在本身的threadLocals中的，也就是本身的ThreadLocalMap；
  4. ThreadLocalMap的鍵值爲ThreadLocal對象，並且能夠有多個threadLocal變量，所以保存在map中；
  5. 在進行get以前，必須先set，不然會報空指針異常，固然也能夠初始化一個，可是必須重寫initialValue()方法；
  6. ThreadLocal自己並不存儲值，它只是做爲一個key來讓線程從ThreadLocalMap獲取value。

ThreadLocal 應用場景

ThreadLocal 的特性也致使了應用場景比較普遍，主要的應用場景以下：

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

總結：面試常見問題

Thread、ThreadLocal 以及 ThreadLocalMap關係

經過對以上源碼的分析，Thread、ThreadLocal 以及 ThreadLocalMap 的關係有了進一步的理解，咱們再經過一張圖來總結下:

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

ThreadLocal 是如何作到線程數據隔離，前面源碼分析 ThreadLocal 的 set 方法已經分析過，這裏咱們再總結一下：

ThreadLocal之因此能達到變量的線程隔離，其實就是每一個線程都有一個本身的ThreadLocalMap對象來存儲同一個threadLocal實例set的值，而取值的時候也是根據同一個threadLocal實例去本身的ThreadLocalMap裏面找，天然就互不影響了，從而達到線程隔離的目的。以下圖所示：

ThreadLocal內存泄漏問題

ThreadLocal 在沒有外部強引用時，發生 GC時會被回收，那麼 ThreadLocalMap 中保存的 key 值就變成了 null，而 Entry 又被 threadLocalMap 對象引用，threadLocalMap 對象又被 Thread 對象所引用，那麼當 Thread 一直不終結的話，value 對象就會一直存在於內存中，也就致使了內存泄漏，直至 Thread 被銷燬後，纔會被回收。咱們經過一張圖來理解下： ThreadLocal內存泄漏的根源是：因爲ThreadLocalMap的生命週期跟Thread同樣長，若是沒有手動刪除對應key就會致使內存泄漏，而不是由於弱引用。

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

在使用完 ThreadLocal 變量後，須要咱們手動 remove 掉，防止 ThreadLocalMap 中的 Entry 一直保持對 value 的強引用，致使 value 不能被回收。

參考

PS：以上代碼提交在 Github ：github.com/Niuh-Study/…

PS：這裏有一個技術交流羣（扣扣羣:1158819530），方便你們一塊兒交流，持續學習，共同進步，有須要的能夠加一下。

文章持續更新，能夠公衆號搜一搜「 一角錢技術 」第一時間閱讀， 本文 GitHub org_hejianhui/JavaStudy 已經收錄，歡迎 Star。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程