前言
ThreadLocal很多同學都搞不懂是什么東西，可以用來干嘛。但面試時卻又經常問到，所以這次我和大家一起學習ThreadLocal這個類。
下面我就以面試問答的形式學習我們的——ThreadLocal類（源碼分析基于JDK8）
問答內容
- 問：ThreadLocal了解嗎？您能給我說說他的主要用途嗎？
答：
首先，ThreadLocal是用在多線程的場景的！！！如果僅僅就一個線程，那么不用談ThreadLocal了。
ThreadLocal歸納下來就2類用途：
- 保存線程上下文信息，在任意需要的地方可以獲取！！！
- 線程安全的，避免某些情況需要考慮線程安全必須同步帶來的性能損失！！！
保存線程上下文信息，在任意需要的地方可以獲取！！！
由于ThreadLocal的特性，同一線程在某地方進行設置，在隨后的任意地方都可以獲取到。從而可以用來保存線程上下文信息。
還有比如Spring的事務管理，用ThreadLocal存儲Connection，從而各個DAO可以獲取同一Connection，可以進行事務回滾，提交等操作。
備注：ThreadLocal的這種用處，很多時候是用在一些優秀的框架里面的，一般我們很少接觸，反而下面的場景我們接觸的更多一些！
線程安全的，避免某些情況需要考慮線程安全必須同步帶來的性能損失！！！
ThreadLocal為解決多線程程序的并發問題提供了一種新的思路。但是ThreadLocal也有局限性，我們來看看阿里規范：
每個線程往ThreadLocal中讀寫數據是線程隔離，互相之間不會影響的，所以ThreadLocal無法解決共享對象的更新問題！
由于不需要共享信息，自然就不存在競爭問題了，從而保證了某些情況下線程的安全，以及避免了某些情況需要考慮線程安全必須同步帶來的性能損失！！！
這類場景阿里規范里面也提到了：
示例代碼：
/**
* 該類提供了線程局部 (thread-local) 變量。 這些變量不同于它們的普通對應物，
* 因為訪問某個變量（通過其 get 或 set 方法）的每個線程都有自己的局部變量
* 它獨立于變量的初始化副本。ThreadLocal 實例通常是類中的 private static 字段
* 它們希望將狀態與某一個線程（例如，用戶 ID 或事務 ID）相關聯。
*
* 例如，以下類生成對每個線程唯一的局部標識符。
*
* 線程 ID 是在第一次調用 UniqueThreadIdGenerator.getCurrentThreadId() 時分配的，
* 在后續調用中不會更改。
* <pre>
* import java.util.concurrent.atomic.AtomicInteger;
*
* public class ThreadId {
* // 原子性整數，包含下一個分配的線程Thread ID
* private static final AtomicInteger nextId = new AtomicInteger(0);
*
* // 每一個線程對應的Thread ID
* private static final ThreadLocal<Integer> threadId =
* new ThreadLocal<Integer>() {
* @Override protected Integer initialValue() {
* return nextId.getAndIncrement();
* }
* };
*
* // 返回當前線程對應的唯一Thread ID, 必要時會進行分配
* public static int get() {
* return threadId.get();
* }
* }
*
* 每個線程都保持對其線程局部變量副本的隱式引用，只要線程是活動的并且 ThreadLocal 實例是可訪問的
* 在線程消失之后，其線程局部實例的所有副本都會被垃圾回收，（除非存在對這些副本的其他引用）。
*
* @author Josh Bloch and Doug Lea
* @since 1.2
*/
public class ThreadLocal<T> {
/**
* 自定義哈希碼（僅在ThreadLocalMaps中有用）
* 可用于降低hash沖突
*/
private final int threadLocalHashCode = nextHashCode();
/**
* 生成下一個哈希碼hashCode. 生成操作是原子性的. 從0開始
*/
private static AtomicInteger nextHashCode =
new AtomicInteger();
/**
* 表示了連續分配的兩個ThreadLocal實例的threadLocalHashCode值的增量
*/
private static final int HASH_INCREMENT = 0x61c88647;
/**
* 返回下一個哈希碼hashCode
*/
private static int nextHashCode() {
return nextHashCode.getAndAdd(HASH_INCREMENT);
}
}
- 其中nextHashCode()方法就是一個原子類不停地去加上0x61c88647，這是一個很特別的數，叫斐波那契散列（Fibonacci Hashing），斐波那契又有一個名稱叫黃金分割，也就是說將這個數作為哈希值的增量將會使哈希表的分布更為均勻。
- 問：ThreadLocal實現原理是什么，它是怎么樣做到局部變量不同的線程之間不會相互干擾的？
答：
每個Thread維護一個ThreadLocalMap哈希表，這個哈希表的key是ThreadLocal實例本身，value才是真正要存儲的值Object。
這樣設計，當Thread銷毀之后，對應的ThreadLocalMap也會隨之銷毀，能減少內存的使用。
- 問：您能說說ThreadLocal常用操作的底層實現原理嗎？如存儲set(T value)，獲取get()，刪除remove()等操作。
答：
調用get()操作獲取ThreadLocal中對應當前線程存儲的值時，進行了如下操作：
- 獲取當前線程Thread對象，進而獲取此線程對象中維護的ThreadLocalMap對象。
- 判斷當前的ThreadLocalMap是否存在：
如果存在，則以當前的ThreadLocal 為 key，調用ThreadLocalMap中的getEntry方法獲取對應的存儲實體 e。找到對應的存儲實體 e，獲取存儲實體 e 對應的 value值，即為我們想要的當前線程對應此ThreadLocal的值，返回結果值。
如果不存在，則證明此線程沒有維護的ThreadLocalMap對象，調用setInitialValue方法進行初始化。返回setInitialValue初始化的值。
setInitialValue方法的操作如下：
- 調用initialValue獲取初始化的值。
- 獲取當前線程Thread對象，進而獲取此線程對象中維護的ThreadLocalMap對象。
- 判斷當前的ThreadLocalMap是否存在：
- 如果存在，則調用map.set設置此實體entry。
- 如果不存在，則調用createMap進行ThreadLocalMap對象的初始化，并將此實體entry作為第一個值存放至ThreadLocalMap中。
PS：關于ThreadLocalMap對應的相關操作，放在下一個問題詳細說明。
示例代碼：
/**
* 返回當前線程對應的ThreadLocal的初始值
* 此方法的第一次調用發生在，當線程通過{@link #get}方法訪問此線程的ThreadLocal值時
* 除非線程先調用了 {@link #set}方法，在這種情況下，
* {@code initialValue} 才不會被這個線程調用。
* 通常情況下，每個線程最多調用一次這個方法，
* 但也可能再次調用，發生在調用{@link #remove}方法后，
* 緊接著調用{@link #get}方法。
*
* <p>這個方法僅僅簡單的返回null {@code null};
* 如果程序員想ThreadLocal線程局部變量有一個除null以外的初始值，
* 必須通過子類繼承{@code ThreadLocal} 的方式去重寫此方法
* 通常, 可以通過匿名內部類的方式實現
*
* @return 當前ThreadLocal的初始值
*/
protected T initialValue() {
return null;
}
/**
* 創建一個ThreadLocal
* @see #withInitial(java.util.function.Supplier)
*/
public ThreadLocal() {
}
/**
* 返回當前線程中保存ThreadLocal的值
* 如果當前線程沒有此ThreadLocal變量，
* 則它會通過調用{@link #initialValue} 方法進行初始化值
*
* @return 返回當前線程對應此ThreadLocal的值
*/
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;
}
}
// 如果map不存在，則證明此線程沒有維護的ThreadLocalMap對象
// 調用setInitialValue進行初始化
return setInitialValue();
}
/**
* set的變樣實現，用于初始化值initialValue，
* 用于代替防止用戶重寫set()方法
*
* @return the initial value 初始化后的值
*/
private T setInitialValue() {
// 調用initialValue獲取初始化的值
T value = initialValue();
// 獲取當前線程對象
Thread t = Thread.currentThread();
// 獲取此線程對象中維護的ThreadLocalMap對象
ThreadLocalMap map = getMap(t);
// 如果此map存在
if (map != null)
// 存在則調用map.set設置此實體entry
map.set(this, value);
else
// 1）當前線程Thread 不存在ThreadLocalMap對象
// 2）則調用createMap進行ThreadLocalMap對象的初始化
// 3）并將此實體entry作為第一個值存放至ThreadLocalMap中
createMap(t, value);
// 返回設置的值value
return value;
}
/**
* 獲取當前線程Thread對應維護的ThreadLocalMap
*
* @param t the current thread 當前線程
* @return the map 對應維護的ThreadLocalMap
*/
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
- 調用set(T value)操作設置ThreadLocal中對應當前線程要存儲的值時，進行了如下操作：
- 獲取當前線程Thread對象，進而獲取此線程對象中維護的ThreadLocalMap對象。
- 判斷當前的ThreadLocalMap是否存在：
- 如果存在，則調用map.set設置此實體entry。
- 如果不存在，則調用createMap進行ThreadLocalMap對象的初始化，并將此實體entry作為第一個值存放至ThreadLocalMap中。
示例代碼：
/**
* 設置當前線程對應的ThreadLocal的值
* 大多數子類都不需要重寫此方法，
* 只需要重寫 {@link #initialValue}方法代替設置當前線程對應的ThreadLocal的值
*
* @param value 將要保存在當前線程對應的ThreadLocal的值
*
*/
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
// 1）當前線程Thread 不存在ThreadLocalMap對象
// 2）則調用createMap進行ThreadLocalMap對象的初始化
// 3）并將此實體entry作為第一個值存放至ThreadLocalMap中
createMap(t, value);
}
/**
* 為當前線程Thread 創建對應維護的ThreadLocalMap.
*
* @param t the current thread 當前線程
* @param firstValue 第一個要存放的ThreadLocal變量值
*/
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
- 調用remove()操作刪除ThreadLocal中對應當前線程已存儲的值時，進行了如下操作：
- 獲取當前線程Thread對象，進而獲取此線程對象中維護的ThreadLocalMap對象。
- 判斷當前的ThreadLocalMap是否存在， 如果存在，則調用map.remove，以當前ThreadLocal為key刪除對應的實體entry。
示例代碼：
/**
* 刪除當前線程中保存的ThreadLocal對應的實體entry
* 如果此ThreadLocal變量在當前線程中調用 {@linkplain #get read}方法
* 則會通過調用{@link #initialValue}進行再次初始化，
* 除非此值value是通過當前線程內置調用 {@linkplain #set set}設置的
* 這可能會導致在當前線程中多次調用{@code initialValue}方法
*
* @since 1.5
*/
public void remove() {
// 獲取當前線程對象中維護的ThreadLocalMap對象
ThreadLocalMap m = getMap(Thread.currentThread());
// 如果此map存在
if (m != null)
// 存在則調用map.remove
// 以當前ThreadLocal為key刪除對應的實體entry
m.remove(this);
}
4.問：對ThreadLocal的常用操作實際是對線程Thread中的ThreadLocalMap進行操作，核心是ThreadLocalMap這個哈希表，你能談談ThreadLocalMap的內部底層實現嗎?
答：
- ThreadLocalMap的底層實現是一個定制的自定義HashMap哈希表，核心組成元素有：
- Entry[] table;：底層哈希表 table, 必要時需要進行擴容，底層哈希表 table.length 長度必須是2的n次方。
- int size;：實際存儲鍵值對元素個數 entries
- int threshold;：下一次擴容時的閾值，閾值 threshold = 底層哈希表table的長度 len * 2 / 3。當size >= threshold時，遍歷table并刪除key為null的元素，如果刪除后size >= threshold*3/4時，需要對table進行擴容（詳情請查看set(ThreadLocal<?> key, Object value)方法說明）。
- 其中Entry[] table;哈希表存儲的核心元素是Entry，Entry包含：
- ThreadLocal<?> k；：當前存儲的ThreadLocal實例對象
- Object value;：當前 ThreadLocal 對應儲存的值value
- 需要注意的是，此Entry繼承了弱引用 WeakReference，所以在使用ThreadLocalMap時，發現key == null，則意味著此key ThreadLocal不在被引用，需要將其從ThreadLocalMap哈希表中移除。(弱引用相關問題解釋請查看 問答 5)
示例代碼：
/**
* ThreadLocalMap 是一個定制的自定義 hashMap 哈希表，只適合用于維護
* 線程對應ThreadLocal的值. 此類的方法沒有在ThreadLocal 類外部暴露，
* 此類是私有的，允許在 Thread 類中以字段的形式聲明 ，
* 以助于處理存儲量大，生命周期長的使用用途，
* 此類定制的哈希表實體鍵值對使用弱引用WeakReferences 作為key，
* 但是, 一旦引用不在被使用，
* 只有當哈希表中的空間被耗盡時，對應不再使用的鍵值對實體才會確保被 移除回收。
*/
static class ThreadLocalMap {
/**
* 實體entries在此hash map中是繼承弱引用 WeakReference,
* 使用ThreadLocal 作為 key 鍵. 請注意，當key為null（i.e. entry.get()
* == null) 意味著此key不再被引用,此時實體entry 會從哈希表中刪除。
*/
static class Entry extends WeakReference<ThreadLocal<?>> {
/** 當前 ThreadLocal 對應儲存的值value. */
Object value;
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}
/**
* 初始容量大小 16 -- 必須是2的n次方.
*/
private static final int INITIAL_CAPACITY = 16;
/**
* 底層哈希表 table, 必要時需要進行擴容.
* 底層哈希表 table.length 長度必須是2的n次方.
*/
private Entry[] table;
/**
* 實際存儲鍵值對元素個數 entries.
*/
private int size = 0;
/**
* 下一次擴容時的閾值
*/
private int threshold; // 默認為 0
/**
* 設置觸發擴容時的閾值 threshold
* 閾值 threshold = 底層哈希表table的長度 len * 2 / 3
*/
private void setThreshold(int len) {
threshold = len * 2 / 3;
}
/**
* 獲取該位置i對應的下一個位置index
*/
private static int nextIndex(int i, int len) {
return ((i + 1 < len) ? i + 1 : 0);
}
/**
* 獲取該位置i對應的上一個位置index
*/
private static int prevIndex(int i, int len) {
return ((i - 1 >= 0) ? i - 1 : len - 1);
}
}
- ThreadLocalMap的構造方法是延遲加載的，也就是說，只有當線程需要存儲對應的ThreadLocal的值時，才初始化創建一次（僅初始化一次）。初始化步驟如下：
- 初始化底層數組table的初始容量為 16。
- 獲取ThreadLocal中的threadLocalHashCode，通過threadLocalHashCode & (INITIAL_CAPACITY - 1)，即ThreadLocal 的 hash 值 threadLocalHashCode % 哈希表的長度 length 的方式計算該實體的存儲位置。
- 存儲當前的實體，key 為 : 當前ThreadLocal value：真正要存儲的值
- 設置當前實際存儲元素個數 size 為 1
- 設置閾值setThreshold(INITIAL_CAPACITY)，為初始化容量 16 的 2/3。
示例代碼：
/**
* 用于創建一個新的hash map包含 (firstKey, firstValue).
* ThreadLocalMaps 構造方法是延遲加載的,所以我們只會在至少有一個
* 實體entry存放時，才初始化創建一次（僅初始化一次）。
*/
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
// 初始化 table 初始容量為 16
table = new Entry[INITIAL_CAPACITY];
// 計算當前entry的存儲位置
// 存儲位置計算等價于：
// ThreadLocal 的 hash 值 threadLocalHashCode % 哈希表的長度 length
int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
// 存儲當前的實體，key 為 : 當前ThreadLocal value：真正要存儲的值
table[i] = new Entry(firstKey, firstValue);
// 設置當前實際存儲元素個數 size 為 1
size = 1;
// 設置閾值，為初始化容量 16 的 2/3。
setThreshold(INITIAL_CAPACITY);
}
- ThreadLocal的get()操作實際是調用ThreadLocalMap的getEntry(ThreadLocal<?> key)方法,此方法快速適用于獲取某一存在key的實體 entry，否則，應該調用getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e)方法獲取，這樣做是為了最大限制地提高直接命中的性能，該方法進行了如下操作：
- 計算要獲取的entry的存儲位置，存儲位置計算等價于：ThreadLocal的 hash 值 threadLocalHashCode % 哈希表的長度 length。
- 根據計算的存儲位置，獲取到對應的實體 Entry。判斷對應實體Entry是否存在 并且 key是否相等：
存在對應實體Entry并且對應key相等，即同一ThreadLocal，返回對應的實體Entry。
不存在對應實體Entry 或者 key不相等，則通過調用getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e)方法繼續查找。
getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e)方法操作如下：
- 獲取底層哈希表數組table，循環遍歷對應要查找的實體Entry所關聯的位置。
- 獲取當前遍歷的entry 的 key ThreadLocal，比較key是否一致，一致則返回。
- 如果key不一致 并且 key 為 null，則證明引用已經不存在，這是因為Entry繼承的是WeakReference，這是弱引用帶來的坑。調用expungeStaleEntry(int staleSlot)方法刪除過期的實體Entry（此方法不單獨解釋，請查看示例代碼，有詳細注釋說明）。
- key不一致 ，key也不為空，則遍歷下一個位置，繼續查找。
- 遍歷完畢，仍然找不到則返回null。
示例代碼：
/**
* 根據key 獲取對應的實體 entry. 此方法快速適用于獲取某一存在key的
* 實體 entry，否則，應該調用getEntryAfterMiss方法獲取，這樣做是為
* 了最大限制地提高直接命中的性能
*
* @param key 當前thread local 對象
* @return the entry 對應key的 實體entry, 如果不存在，則返回null
*/
private Entry getEntry(ThreadLocal<?> key) {
// 計算要獲取的entry的存儲位置
// 存儲位置計算等價于：
// ThreadLocal 的 hash 值 threadLocalHashCode % 哈希表的長度 length
int i = key.threadLocalHashCode & (table.length - 1);
// 獲取到對應的實體 Entry
Entry e = table[i];
// 存在對應實體并且對應key相等，即同一ThreadLocal
if (e != null && e.get() == key)
// 返回對應的實體Entry
return e;
else
// 不存在 或 key不一致，則通過調用getEntryAfterMiss繼續查找
return getEntryAfterMiss(key, i, e);
}
/**
* 當根據key找不到對應的實體entry 時，調用此方法。
* 直接定位到對應的哈希表位置
*
* @param key 當前thread local 對象
* @param i 此對象在哈希表 table中的存儲位置 index
* @param e the entry 實體對象
* @return the entry 對應key的 實體entry, 如果不存在，則返回null
*/
private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
Entry[] tab = table;
int len = tab.length;
// 循環遍歷當前位置的所有實體entry
while (e != null) {
// 獲取當前entry 的 key ThreadLocal
ThreadLocal<?> k = e.get();
// 比較key是否一致，一致則返回
if (k == key)
return e;
// 找到對應的entry ，但其key 為 null，則證明引用已經不存在
// 這是因為Entry繼承的是WeakReference，這是弱引用帶來的坑
if (k == null)
// 刪除過期(stale)的entry
expungeStaleEntry(i);
else
// key不一致 ，key也不為空，則遍歷下一個位置，繼續查找
i = nextIndex(i, len);
// 獲取下一個位置的實體 entry
e = tab[i];
}
// 遍歷完畢，找不到則返回null
return null;
}
/**
* 刪除對應位置的過期實體，并刪除此位置后對應相關聯位置key = null的實體
*
* @param staleSlot 已知的key = null 的對應的位置索引
* @return 對應過期實體位置索引的下一個key = null的位置
* (所有的對應位置都會被檢查)
*/
private int expungeStaleEntry(int staleSlot) {
// 獲取對應的底層哈希表 table
Entry[] tab = table;
// 獲取哈希表長度
int len = tab.length;
// 擦除這個位置上的臟數據
tab[staleSlot].value = null;
tab[staleSlot] = null;
size--;
// 直到我們找到 Entry e = null，才執行rehash操作
// 就是遍歷完該位置的所有關聯位置的實體
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;
// 我們必須一直遍歷直到最后
// 因為還可能存在多個過期的實體
while (tab[h] != null)
h = nextIndex(h, len);
tab[h] = e;
}
}
}
return i;
}
/**
* 刪除所有過期的實體
*/
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);
}
}
- ThreadLocal的set(T value)操作實際是調用ThreadLocalMap的set(ThreadLocal<?> key, Object value)方法，該方法進行了如下操作：
- 獲取對應的底層哈希表table，計算對應threalocal的存儲位置。
- 循環遍歷table對應該位置的實體，查找對應的threadLocal。
- 獲取當前位置的threadLocal，如果key threadLocal一致，則證明找到對應的threadLocal，將新值賦值給找到的當前實體Entry的value中，結束。
- 如果當前位置的key threadLocal不一致，并且key threadLocal為null，則調用replaceStaleEntry(ThreadLocal<?> key, Object value,int staleSlot)方法（此方法不單獨解釋，請查看示例代碼，有詳細注釋說明），替換該位置key == null 的實體為當前要設置的實體，結束。
- 如果當前位置的key threadLocal不一致，并且key threadLocal不為null，則創建新的實體，并存放至當前位置 i tab[i] = new Entry(key, value);，實際存儲鍵值對元素個數size + 1，由于弱引用帶來了這個問題，所以要調用cleanSomeSlots(int i, int n)方法清除無用數據（此方法不單獨解釋，請查看示例代碼，有詳細注釋說明），才能判斷現在的size有沒有達到閥值threshhold，如果沒有要清除的數據，存儲元素個數仍然 大于 閾值 則調用rehash方法進行擴容（此方法不單獨解釋，請查看示例代碼，有詳細注釋說明）。
示例代碼：
/**
* 設置對應ThreadLocal的值
*
* @param key 當前thread local 對象
* @param value 要設置的值
*/
private void set(ThreadLocal<?> key, Object value) {
// 我們不會像get()方法那樣使用快速設置的方式，
// 因為通常很少使用set()方法去創建新的實體
// 相對于替換一個已經存在的實體, 在這種情況下,
// 快速設置方案會經常失敗。
// 獲取對應的底層哈希表 table
Entry[] tab = table;
// 獲取哈希表長度
int len = tab.length;
// 計算對應threalocal的存儲位置
int i = key.threadLocalHashCode & (len-1);
// 循環遍歷table對應該位置的實體，查找對應的threadLocal
for (Entry e = tab[i];e != null;e = tab[i = nextIndex(i, len)]) {
// 獲取當前位置的ThreadLocal
ThreadLocal<?> k = e.get();
// 如果key threadLocal一致，則證明找到對應的threadLocal
if (k == key) {
// 賦予新值
e.value = value;
// 結束
return;
}
// 如果當前位置的key threadLocal為null
if (k == null) {
// 替換該位置key == null 的實體為當前要設置的實體
replaceStaleEntry(key, value, i);
// 結束
return;
}
}
// 當前位置的k ！= key && k != null
// 創建新的實體，并存放至當前位置i
tab[i] = new Entry(key, value);
// 實際存儲鍵值對元素個數 + 1
int sz = ++size;
// 由于弱引用帶來了這個問題，所以先要清除無用數據，才能判斷現在的size有沒有達到閥值threshhold
// 如果沒有要清除的數據，存儲元素個數仍然 大于 閾值 則擴容
if (!cleanSomeSlots(i, sz) && sz >= threshold)
// 擴容
rehash();
}
/**
* 當執行set操作時，獲取對應的key threadLocal，并替換過期的實體
* 將這個value值存儲在對應key threadLocal的實體中，無論是否已經存在體
* 對應的key threadLocal
*
* 有一個副作用, 此方法會刪除該位置下和該位置nextIndex對應的所有過期的實體
*
* @param key 當前thread local 對象
* @param value 當前thread local 對象對應存儲的值
* @param staleSlot 第一次找到此過期的實體對應的位置索引index
* .
*/
private void replaceStaleEntry(ThreadLocal<?> key, Object value,
int staleSlot) {
// 獲取對應的底層哈希表 table
Entry[] tab = table;
// 獲取哈希表長度
int len = tab.length;
Entry e;
// 往前找，找到table中第一個過期的實體的下標
// 清理整個table是為了避免因為垃圾回收帶來的連續增長哈希的危險
// 也就是說，哈希表沒有清理干凈，當GC到來的時候，后果很嚴重
// 記錄要清除的位置的起始首位置
int slotToExpunge = staleSlot;
// 從該位置開始，往前遍歷查找第一個過期的實體的下標
for (int i = prevIndex(staleSlot, len);
(e = tab[i]) != null;
i = prevIndex(i, len))
if (e.get() == null)
slotToExpunge = i;
// 找到key一致的ThreadLocal或找到一個key為 null的
for (int i = nextIndex(staleSlot, len);
(e = tab[i]) != null;
i = nextIndex(i, len)) {
ThreadLocal<?> k = e.get();
// 如果我們找到了key，那么我們就需要把它跟新的過期數據交換來保持哈希表的順序
// 那么剩下的過期Entry呢，就可以交給expungeStaleEntry方法來擦除掉
// 將新設置的實體放置在此過期的實體的位置上
if (k == key) {
// 替換，將要設置的值放在此過期的實體中
e.value = value;
tab[i] = tab[staleSlot];
tab[staleSlot] = e;
// 如果存在，則開始清除之前過期的實體
if (slotToExpunge == staleSlot)
slotToExpunge = i;
// 在這里開始清除過期數據
cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
return;
}
// / 如果我們沒有在往后查找中找沒有找到過期的實體，
// 那么slotToExpunge就是第一個過期Entry的下標了
if (k == null && slotToExpunge == staleSlot)
slotToExpunge = i;
}
// 最后key仍沒有找到，則將要設置的新實體放置
// 在原過期的實體對應的位置上。
tab[staleSlot].value = null;
tab[staleSlot] = new Entry(key, value);
// 如果該位置對應的其他關聯位置存在過期實體，則清除
if (slotToExpunge != staleSlot)
cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
}
/**
* 啟發式的掃描查找一些過期的實體并清除，
* 此方法會再添加新實體的時候被調用,
* 或者過期的元素被清除時也會被調用.
* 如果實在沒有過期數據，那么這個算法的時間復雜度就是O(log n)
* 如果有過期數據，那么這個算法的時間復雜度就是O(n)
*
* @param i 一個確定不是過期的實體的位置，從這個位置i開始掃描
*
* @param n 掃描控制: 有{@code log2(n)} 單元會被掃描,
* 除非找到了過期的實體, 在這種情況下
* 有{@code log2(table.length)-1} 的格外單元會被掃描.
* 當調用插入時, 這個參數的值是存儲實體的個數，
* 但如果調用 replaceStaleEntry方法, 這個值是哈希表table的長度
* (注意: 所有的這些都可能或多或少的影響n的權重
* 但是這個版本簡單，快速，而且似乎執行效率還可以）
*
* @return true 返回true，如果有任何過期的實體被刪除。
*/
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;
}
/**
* 哈希表擴容方法
* 首先掃描整個哈希表table，刪除過期的實體
* 縮小哈希表table大小 或 擴大哈希表table大小，擴大的容量是加倍.
*/
private void rehash() {
// 刪除所有過期的實體
expungeStaleEntries();
// 使用較低的閾值threshold加倍以避免滯后
// 存儲實體個數 大于等于 閾值的3/4則擴容
if (size >= threshold - threshold / 4)
resize();
}
/**
* 擴容方法，以2倍的大小進行擴容
* 擴容的思想跟HashMap很相似，都是把容量擴大兩倍
* 不同之處還是因為WeakReference帶來的
*/
private void resize() {
// 記錄舊的哈希表
Entry[] oldTab = table;
// 記錄舊的哈希表長度
int oldLen = oldTab.length;
// 新的哈希表長度為舊的哈希表長度的2倍
int newLen = oldLen * 2;
// 創建新的哈希表
Entry[] newTab = new Entry[newLen];
int count = 0;
// 逐一遍歷舊的哈希表table的每個實體，重新分配至新的哈希表中
for (int j = 0; j < oldLen; ++j) {
// 獲取對應位置的實體
Entry e = oldTab[j];
// 如果實體不會null
if (e != null) {
// 獲取實體對應的ThreadLocal
ThreadLocal<?> k = e.get();
// 如果該ThreadLocal 為 null
if (k == null) {
// 則對應的值也要清除
// 就算是擴容，也不能忘了為擦除過期數據做準備
e.value = null; // Help the GC
} else {
// 如果不是過期實體，則根據新的長度重新計算存儲位置
int h = k.threadLocalHashCode & (newLen - 1);
// 將該實體存儲在對應ThreadLocal的最后一個位置
while (newTab[h] != null)
h = nextIndex(h, newLen);
newTab[h] = e;
count++;
}
}
}
// 重新分配位置完畢，則重新計算閾值Threshold
setThreshold(newLen);
// 記錄實際存儲元素個數
size = count;
// 將新的哈希表賦值至底層table
table = newTab;
}
ThreadLocal的remove()操作實際是調用ThreadLocalMap的remove(ThreadLocal<?> key)方法，該方法進行了如下操作：
1 ) 獲取對應的底層哈希表 table，計算對應threalocal的存儲位置。
2 ) 循環遍歷table對應該位置的實體，查找對應的threadLocal。
3 ) 獲取當前位置的threadLocal，如果key threadLocal一致，則證明找到對應的threadLocal，執行刪除操作，刪除此位置的實體，結束。
示例代碼：
/**
* 移除對應ThreadLocal的實體
*/
private void remove(ThreadLocal<?> key) {
// 獲取對應的底層哈希表 table
Entry[] tab = table;
// 獲取哈希表長度
int len = tab.length;
// 計算對應threalocal的存儲位置
int i = key.threadLocalHashCode & (len-1);
// 循環遍歷table對應該位置的實體，查找對應的threadLocal
for (Entry e = tab[i];e != null;e = tab[i = nextIndex(i, len)]) {
// 如果key threadLocal一致，則證明找到對應的threadLocal
if (e.get() == key) {
// 執行清除操作
e.clear();
// 清除此位置的實體
expungeStaleEntry(i);
// 結束
return;
}
}
}
- 問：ThreadLocalMap中的存儲實體Entry使用ThreadLocal作為key，但這個Entry是繼承弱引用WeakReference的，為什么要這樣設計，使用了弱引用WeakReference會造成內存泄露問題嗎？
答：首先，回答這個問題之前，我需要解釋一下什么是強引用，什么是弱引用。
我們在正常情況下，普遍使用的是強引用：
A a = new A();
B b = new B();當 a = null;b = null;時，一段時間后，JAVA垃圾回收機制GC會將 a 和 b 對應所分配的內存空間給回收。
但考慮這樣一種情況：
C c = new C(b);
b = null;
當 b 被設置成null時，那么是否意味這一段時間后GC工作可以回收 b 所分配的內存空間呢？答案是否定的，因為即使 b 被設置成null，但 c 仍然持有對 b 的引用，而且還是強引用，所以GC不會回收 b 原先所分配的空間，既不能回收，又不能使用，這就造成了 內存泄露。
那么如何處理呢？
可以通過c = null;，也可以使用弱引用WeakReference w = new WeakReference(b);。因為使用了弱引用WeakReference，GC是可以回收 b 原先所分配的空間的。
回到ThreadLocal的層面上，ThreadLocalMap使用ThreadLocal的弱引用作為key，如果一個ThreadLocal沒有外部強引用來引用它，那么系統 GC 的時候，這個ThreadLocal勢必會被回收，這樣一來，ThreadLocalMap中就會出現key為null的Entry，就沒有辦法訪問這些key為null的Entry的value，如果當前線程再遲遲不結束的話，這些key為null的Entry的value就會一直存在一條強引用鏈：Thread Ref -> Thread -> ThreaLocalMap -> Entry -> value 永遠無法回收，造成內存泄漏。
其實，ThreadLocalMap的設計中已經考慮到這種情況，也加上了一些防護措施：在ThreadLocal的get(),set(),remove()的時候都會清除線程ThreadLocalMap里所有key為null的value。
但是這些被動的預防措施并不能保證不會內存泄漏：
- 使用static的ThreadLocal，延長了ThreadLocal的生命周期，可能導致的內存泄漏。
- 分配使用了ThreadLocal又不再調用get(),set(),remove()方法，那么就會導致內存泄漏。
從表面上看內存泄漏的根源在于使用了弱引用。網上的文章大多著重分析ThreadLocal使用了弱引用會導致內存泄漏，但是另一個問題也同樣值得思考：為什么使用弱引用而不是強引用？
我們先來看看官方文檔的說法：
To help deal with very large and long-lived usages,
the hash table entries use WeakReferences for keys.
為了應對非常大和長時間的用途，哈希表使用弱引用的 key。
下面我們分兩種情況討論：
key 使用強引用：引用的ThreadLocal的對象被回收了，但是ThreadLocalMap還持有ThreadLocal的強引用，如果沒有手動刪除，ThreadLocal不會被回收，導致Entry內存泄漏。
key 使用弱引用：引用的ThreadLocal的對象被回收了，由于ThreadLocalMap持有ThreadLocal的弱引用，即使沒有手動刪除，ThreadLocal也會被回收。value在下一次ThreadLocalMap調用get(),set(),remove()的時候會被清除。
比較兩種情況，我們可以發現：由于ThreadLocalMap的生命周期跟Thread一樣長，如果都沒有手動刪除對應key，都會導致內存泄漏，但是使用弱引用可以多一層保障：弱引用ThreadLocal不會內存泄漏，對應的value在下一次ThreadLocalMap調用get(),set(),remove()的時候會被清除。
因此，ThreadLocal內存泄漏的根源是：由于ThreadLocalMap的生命周期跟Thread一樣長，如果沒有手動刪除對應key就會導致內存泄漏，而不是因為弱引用。
綜合上面的分析，我們可以理解ThreadLocal內存泄漏的前因后果，那么怎么避免內存泄漏呢？
每次使用完ThreadLocal，都調用它的remove()方法，清除數據。
在使用線程池的情況下，沒有及時清理ThreadLocal，不僅是內存泄漏的問題，更嚴重的是可能導致業務邏輯出現問題。所以，使用ThreadLocal就跟加鎖完要解鎖一樣，用完就清理。
- 問：ThreadLocal和synchronized的區別?
答：ThreadLocal和synchronized關鍵字都用于處理多線程并發訪問變量的問題，只是二者處理問題的角度和思路不同。
ThreadLocal是一個Java類,通過對當前線程中的局部變量的操作來解決不同線程的變量訪問的沖突問題。所以，ThreadLocal提供了線程安全的共享對象機制，每個線程都擁有其副本。
Java中的synchronized是一個保留字，它依靠JVM的鎖機制來實現臨界區的函數或者變量的訪問中的原子性。在同步機制中，通過對象的鎖機制保證同一時間只有一個線程訪問變量。此時，被用作“鎖機制”的變量時多個線程共享的。
同步機制(synchronized關鍵字)采用了以“時間換空間”的方式，提供一份變量，讓不同的線程排隊訪問。而ThreadLocal采用了“以空間換時間”的方式，為每一個線程都提供一份變量的副本，從而實現同時訪問而互不影響。
- 問：ThreadLocal在現時有什么應用場景？
答：總的來說ThreadLocal主要是解決2種類型的問題：
解決并發問題：使用ThreadLocal代替synchronized來保證線程安全。同步機制采用了“以時間換空間”的方式，而ThreadLocal采用了“以空間換時間”的方式。前者僅提供一份變量，讓不同的線程排隊訪問，而后者為每一個線程都提供了一份變量，因此可以同時訪問而互不影響。
解決數據存儲問題：ThreadLocal為變量在每個線程中都創建了一個副本，所以每個線程可以訪問自己內部的副本變量，不同線程之間不會互相干擾。如一個Parameter對象的數據需要在多個模塊中使用，如果采用參數傳遞的方式，顯然會增加模塊之間的耦合性。此時我們可以使用ThreadLocal解決。
應用場景：
Spring使用ThreadLocal解決線程安全問題
我們知道在一般情況下，只有無狀態的Bean才可以在多線程環境下共享，在Spring中，絕大部分Bean都可以聲明為singleton作用域。就是因為Spring對一些Bean（如RequestContextHolder、TransactionSynchronizationManager、LocaleContextHolder等）中非線程安全狀態采用ThreadLocal進行處理，讓它們也成為線程安全的狀態，因為有狀態的Bean就可以在多線程中共享了。
一般的Web應用劃分為展現層、服務層和持久層三個層次，在不同的層中編寫對應的邏輯，下層通過接口向上層開放功能調用。在一般情況下，從接收請求到返回響應所經過的所有程序調用都同屬于一個線程ThreadLocal是解決線程安全問題一個很好的思路，它通過為每個線程提供一個獨立的變量副本解決了變量并發訪問的沖突問題。在很多情況下，ThreadLocal比直接使用synchronized同步機制解決線程安全問題更簡單，更方便，且結果程序擁有更高的并發性。
示例代碼：
public abstract class RequestContextHolder {
····
private static final boolean jsfPresent =
ClassUtils.isPresent("javax.faces.context.FacesContext", RequestContextHolder.class.getClassLoader());
private static final ThreadLocal<RequestAttributes> requestAttributesHolder =
new NamedThreadLocal<RequestAttributes>("Request attributes");
private static final ThreadLocal<RequestAttributes> inheritableRequestAttributesHolder =
new NamedInheritableThreadLocal<RequestAttributes>("Request context");
}
總結
ThreadLocal提供線程內部的局部變量，在本線程內隨時隨地可取，隔離其他線程。
ThreadLocal的設計是：每個Thread維護一個ThreadLocalMap哈希表，這個哈希表的key是ThreadLocal實例本身，value才是真正要存儲的值Object。
對ThreadLocal的常用操作實際是對線程Thread中的ThreadLocalMap進行操作。
ThreadLocalMap的底層實現是一個定制的自定義HashMap哈希表，ThreadLocalMap的閾值threshold = 底層哈希表table的長度 len * 2 / 3，當實際存儲元素個數size 大于或等于 閾值threshold的 3/4 時size >= threshold*3/4，則對底層哈希表數組table進行擴容操作。
ThreadLocalMap中的哈希表Entry[] table存儲的核心元素是Entry，存儲的key是ThreadLocal實例對象，value是ThreadLocal 對應儲存的值value。需要注意的是，此Entry繼承了弱引用 WeakReference，所以在使用ThreadLocalMap時，發現key == null，則意味著此key ThreadLocal不在被引用，需要將其從ThreadLocalMap哈希表中移除。
ThreadLocalMap使用ThreadLocal的弱引用作為key，如果一個ThreadLocal沒有外部強引用來引用它，那么系統 GC 的時候，這個ThreadLocal勢必會被回收。所以，在ThreadLocal的get(),set(),remove()的時候都會清除線程ThreadLocalMap里所有key為null的value。如果我們不主動調用上述操作，則會導致內存泄露。
為了安全地使用ThreadLocal，必須要像每次使用完鎖就解鎖一樣，在每次使用完ThreadLocal后都要調用remove()來清理無用的Entry。這在操作在使用線程池時尤為重要。
ThreadLocal和synchronized的區別：同步機制(synchronized關鍵字)采用了以“時間換空間”的方式，提供一份變量，讓不同的線程排隊訪問。而ThreadLocal采用了“以空間換時間”的方式，為每一個線程都提供一份變量的副本，從而實現同時訪問而互不影響。
ThreadLocal主要是解決2種類型的問題：A. 解決并發問題：使用ThreadLocal代替同步機制解決并發問題。B. 解決數據存儲問題：如一個Parameter對象的數據需要在多個模塊中使用，如果采用參數傳遞的方式，顯然會增加模塊之間的耦合性。此時我們可以使用ThreadLocal解決。
歡迎關注我的公眾號
