一文搞懂 ThreadLocal 原理

• 2020 年 4 月 5 日
• 筆記

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

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

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

什麼是 ThreadLocal？

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

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

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

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

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("wupx");          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("huxy");                  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執行緒取到的值：wupx  Thread-0執行緒取到的值：null  重新設置之後Thread-0執行緒取到的值為：huxy  Thread-0執行緒執行結束  Thread-0執行緒執行之後，main執行緒取到的值：wupx  

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

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

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，ThreadLocalMap 是 ThreadLocal 的靜態內部類，當一個執行緒有多個 ThreadLocal 時，需要一個容器來管理多個 ThreadLocal，ThreadLocalMap 的作用就是管理執行緒中多個 ThreadLocal，源碼如下：

static class ThreadLocalMap {  	/**  	 * 鍵值對實體的存儲結構  	 */  	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;  		}  	}    	// 初始容量，必須為 2 的冪  	private static final int INITIAL_CAPACITY = 16;    	// 存儲 ThreadLocal 的鍵值對實體數組，長度必須為 2 的冪  	private Entry[] table;    	// ThreadLocalMap 元素數量  	private int size = 0;    	// 擴容的閾值，默認是數組大小的三分之二  	private int threshold;  }  

從源碼中看到 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 源碼如下所示：

/**   * 清理當前 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 是如何實現執行緒隔離的呢？

ThreadLocal 的 set 方法

我們先去看下 ThreadLocal 的 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 給保存進去。set 方法的流程主要是：

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

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

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

/**   * 返回當前執行緒 thread 持有的 ThreadLocalMap   *   * @param t 當前執行緒   * @return ThreadLocalMap   */  ThreadLocalMap getMap(Thread t) {  	return t.threadLocals;  }  

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

/**   * ThreadLocal 的 ThreadLocalMap 是執行緒的一個屬性，所以在多執行緒環境下 threadLocals 是執行緒安全的   */  ThreadLocal.ThreadLocalMap threadLocals = null;  

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

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

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

/**   * 在 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();  	}  }  

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

ThreadLocal 的 get 方法

了解完 set 方法後，讓我們看下 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 方法的主要流程為：

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

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

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

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

/**   * 返回 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);  	}  }  

ThreadLocalMap 的 resize 方法

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

/**   * 擴容，重新計算索引，標記垃圾值，方便 GC 回收   */  private void resize() {  	Entry[] oldTab = table;  	int oldLen = oldTab.length;  	int newLen = oldLen * 2;  	// 新建一個數組，按照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;  			} 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;  }  

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

ThreadLocal 應用場景

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

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

總結

本文主要從源碼的角度解析了 ThreadLocal，並分析了發生記憶體泄漏的原因，最後對它的應用場景進行了簡單介紹。

歡迎留言交流討論，原創不易，覺得文章不錯，請在看轉發支援一下。

更詳細的源碼解析可以點擊鏈接查看：https://github.com/wupeixuan/JDKSourceCode1.8

參考

《Java並發編程實戰》

https://www.javaspecialists.eu/archive/Issue164.html

https://mp.weixin.qq.com/s/vURwBPgVuv4yGT1PeEHxZQ

Java並發編程學習寶典

面試官系統精講Java源碼及大廠真題

Java 並發麵試 78 講