拍拍叫痛的无挡视频免费,久久免费公开视频,亚洲日本视频在线观看

前言

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

ThreadLocal 是什么?
ThreadLocal 怎么用?
ThreadLocal 和線程同步機制相比較?
ThreadLocal 是如何實現線程隔離的呢?
ThreadLocal 如何避免內存泄漏呢?
ThreadLocal 與 Thread、ThreadLocalMap 之間的關系?

以下分析均基于JDK1.8。

什么是ThreadLocal

ThreadLocal，很多地方叫做線程本地變量，也有些地方叫做線程本地存儲。

ThreadLocal為變量在每個線程中都創建了一個副本，那么每個線程可以訪問自己內部的副本變量，這樣同時多個線程訪問該變量并不會彼此相互影響，因此他們使用的都是自己從內存中拷貝過來的變量的副本，這樣就不存在線程安全問題，也不會影響程序的執行性能。

注意：雖然ThreadLocal能夠解決上面說的問題，但是由于在每個線程中都創建了副本，所以要考慮它對資源的消耗，比如內存的占用會比不使用ThreadLocal要大。

ThreadLocal 怎么用

通常使用靜態的變量來維護ThreadLocal，如:

static ThreadLocal<String> sThreadLocal = new ThreadLocal<String>

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

通過一個例子來了解 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實例)的引用是一個弱引用。

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

構造方法

1.ThreadLocalMap 提供了兩個構造方法：

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，遞增生成。

2.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，判斷是否需要修改位置。

2.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進行擦除。

3.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沖突。

2.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)才會進行擴容。

3.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 給保存進去。其主要流程為：

先獲取當當前線程的引用;
利用這個引用來獲取到 ThreadLocalMap;
如果 map 為空，則去創建一個 ThreadLocalMap;
如果 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 方法的主要流程為：

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

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

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

小結

通過對源碼的分析，現在我們來總結一下：

每個Thread維護著一個ThreadLocalMap的引用;
ThreadLocalMap是ThreadLocal的內部類，用Entry來進行存儲;
ThreadLocal創建的副本是存儲在自己的threadLocals中的，也就是自己的ThreadLocalMap;
ThreadLocalMap的鍵值為ThreadLocal對象，而且可以有多個threadLocal變量，因此保存在map中;
在進行get之前，必須先set，否則會報空指針異常，當然也可以初始化一個，但是必須重寫initialValue()方法;
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 被銷毀后，才會被回收。我們通過一張圖來理解下：