精通高并發(fā)與多線程，卻不會用ThreadLocal？
本文轉載自微信公眾號「小菜良記」，作者小菜良記。轉載本文請聯(lián)系小菜良記公眾號。
ThreadLocal 簡介
概念ThreadLocal 類是用來提供線程內部的局部變量。這種變量在多線程環(huán)境下訪問(get 和set 方法訪問)時能保證各個線程的變量相對獨立于其他線程內的變量。ThreadLocal 實例通常來說都是 private static 類型的，用于關聯(lián)線程和上下文。
作用
- 傳遞數(shù)據(jù)
提供線程內部的局部變量。可以通過 ThreadLocal 在同一線程，不同組件中傳遞公共變量。
- 線程并發(fā)
適用于多線程并發(fā)情況下。
- 線程隔離
每個線程的變量都是獨立的，不會相互影響。
ThreadLocal 實戰(zhàn)
1. 常見方法
- ThreadLocal ()
構造方法，創(chuàng)建一個 ThreadLocal 對象
- void set (T value)
設置當前線程綁定的局部變量
- T get ()
獲取當前線程綁定的局部變量
- void remove ()
移除當前線程綁定的局部變量
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();
- }
- }
- }
我們理想中的代碼輸出結果應該是這樣的：
- /** 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
但是實際上輸出的結果卻是這樣的：
- /** 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
順序亂了沒有關系，但是我們可以看到 Thread-0 這個線程拿到的值卻是 Thread-1
從結果中我們可以看出多個線程在訪問同一個變量的時候會出現(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
從結果上看，加鎖好像是解決了上述問題，但是 synchronized 常用于多線程數(shù)據(jù)共享的問題，而非多線程數(shù)據(jù)隔離的問題。這里使用 synchronized 雖然解決了問題，但是多少有些不合適，并且 synchronized 屬于重量級鎖，為了實現(xiàn)多線程數(shù)據(jù)隔離貿然的加上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();
- }
- }
- }
在查看輸出結果之前，我們先來看看代碼發(fā)生了那些變化
首先多了一個 private static 修飾的 ThreadLocal ，然后在 setName 的時候，我們實際上是往 ThreadLocal 里面存數(shù)據(jù)，在 getName 的時候，我們是在 ThreadLocal 里面取數(shù)據(jù)。感覺操作上也是挺簡單的，但是這樣真的能做到線程間的數(shù)據(jù)隔離嗎，我們再來看一看結果：
- /** 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
從結果上可以看到每個線程都能取到對應的數(shù)據(jù)。ThreadLocal 也已經解決了多線程之間數(shù)據(jù)隔離的問題。
那么我們來小結一下，為什么需要使用ThreadLocal，與 synchronized 的區(qū)別是什么
- synchronized
原理： 同步機制采用 "以時間換空間" 的方式，只提供了一份變量，讓不同線程排隊訪問
側重點： 多個線程之間同步訪問資源
- ThreadLocal
原理： ThreadLocal 采用 "以空間換時間" 的方式，為每個線程都提供了一份變量的副本，從而實現(xiàn)同時訪問而互不干擾
側重點： 多線程中讓每個線程之間的數(shù)據(jù)相互隔離
3. 內部結構
從上面的案例中我們可以看到 ThreadLocal 的兩個主要方法分別是 set() 和 get()
那我們不妨猜想一下，如果讓我們來設計 ThreadLocal ，我們該如何設計，是否會有這樣的想法：每個 ThreadLocal 都創(chuàng)建一個 Map，然后用線程作為 Map 的 key，要存儲的局部變量作為 Map 的 value ，這樣就能達到各個線程的局部變量隔離的效果。
這個想法也是沒錯的，早期的 ThreadLocal 便是這樣設計的，但是在 JDK 8 之后便更改了設計，如下：
設計過程：
- 每個 Thread 線程內部都有一個 ThreadLocalMap
- ThreadLocalMap 中存儲著以 ThreadLocal 對象為 key ，線程變量為 value
- Thread 內部的 Map 是由 ThreadLocal 維護的，由 ThreadLocal 負責向 Map 設置和獲取線程的變量值
- 對于不同的線程，每次獲取副本值時，別的線程并不能獲取到線程的副本值，這樣就會形成副本的隔離，互不干擾
注： 每個線程都要有自己的一個 map，但是這個類就是一個普通的 Java 類，并沒有實現(xiàn)Map 接口，但是具有類似 Map 類似的功能。
通過這樣實現(xiàn)看起來貌似會比之前我們猜想的更加復雜，這樣做的好處是什么呢?
- 每個 Map 存儲的 Entry 數(shù)量就會變少，因為之前的存儲數(shù)量由 Thread 的數(shù)量決定，現(xiàn)在是由 ThreadMap 的數(shù)量決定，在實際開發(fā)中，ThreadLocal 的數(shù)量要更少于Thread 的數(shù)量。
- 當 Thread 銷毀之后，對應的 ThreadLocalMap 也會隨之銷毀，能減少內存的使用
4. 源碼分析
首先我們先看 ThreadLocalMap 中有哪些成員：
如果你看過 HashMap 的源碼，肯定會覺得這幾個特別熟悉，其中：
- INITIAL_CAPACITY：初始容量，必須是 2 的整次冪
- table：存放數(shù)據(jù)的table
- size：數(shù)組中 entries 的個數(shù)，用于判斷 table 當前使用量是否超過閾值
- threshold：進行擴容的閾值，表使用量大于它的時候會進行擴容
ThreadLocals
Thread 類中有個類型為 ThreadLocal.ThreadLocalMap 類型的變量 ThreadLocals ，這個就是用來保存每個線程的私有數(shù)據(jù)。
ThreadLocalMap
ThreadLocalMap是ThreadLocal的內部類，每個數(shù)據(jù)用Entry保存，其中的Entry用一個鍵值對存儲，鍵為ThreadLocal的引用。
我們可以看到 Entry 繼承于WeakReference，這是因為如果是強引用，即使把ThreadLocal 設置為 null，GC 也不會回收，因為 ThreadLocalMap 對它有強引用。
在沒有手動刪除這個Entry以及CurrentThread依然運行的前提下，始終有強引用鏈threadRef -> currentThread -> threadLocalMap -> entry，Entry就不會被回收(Entry中包括了ThreadLocal實例和value)，導致Entry內存泄漏。
那是不是就是說如果使用了弱引用，就不會造成內存泄露 呢，這也是不正確的。
因為如果我們沒有手動刪除 Entry 的情況下，此時 Entry 中的 key == null，這個時候沒有任何強引用指向 threaLocal 實例，所以 threadLocal 就可以順利被 gc 回收，但是value 不會被回收，而這塊的 value 永遠不會被訪問到，因此會導致內存泄露
接下來我們看下 ThreadLocalMap 的幾個核心方法：
set 方法
首先我們先看下源碼：
- public void set(T value) {
- // 獲取當前線程對象
- Thread t = Thread.currentThread();
- // 獲取此線程對象中維護的ThreadLocalMap對象
- ThreadLocalMap map = getMap(t);
- // 判斷map是否存在
- if (map != null)
- // 存在則調用map.set設置此實體entry
- map.set(this, value);
- else
- // 如果當前線程不存在ThreadLocalMap對象則調用createMap進行ThreadLocalMap對象的初始化
- // 并將 t(當前線程)和value(t對應的值)作為第一個entry存放至ThreadLocalMap中
- createMap(t, value);
- }
- ThreadLocalMap getMap(Thread t) {
- return t.threadLocals;
- }
- void createMap(Thread t, T firstValue) {
- //這里的this是調用此方法的threadLocal
- t.threadLocals = new ThreadLocalMap(this, firstValue);
- }
執(zhí)行流程：
- 首先獲取當前線程，并根據(jù)當前線程獲取一個 map
- 如果獲取的 map 不為空，則將參數(shù)設置到 map 中(當前 ThreadLocal 的引用作為key )
- 如果 Map 為空，則給該線程創(chuàng)建 map ，并設置初始值
get 方法
源碼如下：
- public T get() {
- // 獲取當前線程對象
- Thread t = Thread.currentThread();
- // 獲取此線程對象中維護的ThreadLocalMap對象
- ThreadLocalMap map = getMap(t);
- // 如果此map存在
- if (map != null) {
- // 以當前的ThreadLocal 為 key，調用getEntry獲取對應的存儲實體e
- ThreadLocalMap.Entry e = map.getEntry(this);
- // 對e進行判空
- if (e != null) {
- @SuppressWarnings("unchecked")
- // 獲取存儲實體 e 對應的 value值
- // 即為我們想要的當前線程對應此ThreadLocal的值
- T result = (T)e.value;
- return result;
- }
- }
- return setInitialValue();
- }
- private T setInitialValue() {
- // 調用initialValue獲取初始化的值
- // 此方法可以被子類重寫, 如果不重寫默認返回null
- T value = initialValue();
- // 獲取當前線程對象
- Thread t = Thread.currentThread();
- // 獲取此線程對象中維護的ThreadLocalMap對象
- ThreadLocalMap map = getMap(t);
- // 判斷map是否存在
- if (map != null)
- // 存在則調用map.set設置此實體entry
- map.set(this, value);
- else
- // 如果當前線程不存在ThreadLocalMap對象則調用createMap進行ThreadLocalMap對象的初始化
- // 并將 t(當前線程)和value(t對應的值)作為第一個entry存放至ThreadLocalMap中
- createMap(t, value);
- // 返回設置的值value
- return value;
- }
執(zhí)行流程：
- 首先獲取當前線程，根據(jù)當前線程獲取一個 map
- 如果獲取的 map 不為空，則在 map 中以 ThreadLocal 的引用作為 key 來在 map 中獲取對應的 Entry entry ，否則跳轉到第四步
- 如果 Entry entry 不為空 ，則返回 entry.value ，否則跳轉到第四步
- map 為空或者 entry 為空，則通過 initialValue 函數(shù)獲取初始值 value ，然后用ThreadLocal 的引用和 value 作為 firstKey 和 firstValue 創(chuàng)建一個新的 map
remove 方法
源碼如下：
- public void remove() {
- // 獲取當前線程對象中維護的ThreadLocalMap對象
- ThreadLocalMap m = getMap(Thread.currentThread());
- // 如果此map存在
- if (m != null)
- // 存在則調用map.remove
- m.remove(this);
- }
- // 以當前ThreadLocal為key刪除對應的實體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í)行流程：
首先獲取當前線程，并根據(jù)當前線程獲取一個 map
如果獲得的map 不為空，則移除當前 ThreadLocal 對象對應的 entry
initialValue 方法
源碼如下：
- protected T initialValue() {
- return null;
- }
在源碼中我們可以看到這個方法僅僅簡單的返回了 null ，這個方法是在線程第一次通過get () 方法訪問該線程的 ThreadLocal 時調用的，只有在線程先調用了 set () 方法才不會調用 initialValue () 方法，通常情況下，這個方法最多被調用一次。
如果們想要 ThreadLocal 線程局部變量有一個除 null 以外的初始值，那么就必須通過子類繼承 ThreadLocal 來重寫此方法，可以通過匿名內部類實現(xiàn)。
