ThreadLocal
這個類提供線程局部變量。這些變量在每一個線程中的正常副本都不相同，每一個線程訪問一個副本（通過其 get或 set法），副本有自己獨立的變量初始化複製。ThreadLocal實例通常是類中私有的靜態字段希望關聯狀態和線程（例如，一個用戶ID或交易ID）。
例如，下面的類爲每個線程生成唯一的標識符。一個線程的ID在第一次調用ThreadId.get()時分配並且在後續調用中保持不變。
public class ThreadId {
// Atomic integer containing the next thread ID to be assigned
private static final AtomicInteger nextId = new AtomicInteger(0);
// Thread local variable containing each thread's ID
private static final ThreadLocal<Integer> threadId =
new ThreadLocal<Integer>() {
@Override protected Integer initialValue() {
return nextId.getAndIncrement();
}
};
// Returns the current thread's unique ID, assigning it if necessary
public static int get() {
return threadId.get();
}
}每一個線程在活着的時候就持有一個暗示對它線程本地變量拷貝的引用並且ThreadLocal實例可以訪問；線程死去後它的線程本地實例拷貝受垃圾回收管轄（除非存在其他對這些副本引用）。
——以上是對ThreadLocal註釋的翻譯
ThreadLocal是作爲key值存儲在ThreadLocalMap裏面的，而ThreadLocalMap是一個典型的hash表，它的實例存儲在了Thread.threadLocals，並且由於並非所有線程實例都需要用到threadLocals，它是懶漢式的初始化，在第一次插入時纔會初始化創建ThreadLocalMap實例。輸入的value是一個泛型對象，它可以是Integer、Double等基本裝箱類型，也可以是自定義的bean類，可以認爲Thread實例t擁有一個ThreadLocalMap實例threadLocals，它是一個hash表，它以ThreadLocal的實例作爲key值，以具體內容泛型變量value作爲value值，每個線程在存活期間有自己的ThreadLocalMap實例，所以各線程間互不干涉。
public class ThreadLocalTest {
ThreadLocal<Long> longLocal = new ThreadLocal<Long>();
ThreadLocal<String> stringLocal = new ThreadLocal<String>();
public void set() {
longLocal.set(Thread.currentThread().getId());
stringLocal.set(Thread.currentThread().getName());
}
public long getLong() {
return longLocal.get();
}
public String getString() {
return stringLocal.get();
}
public static void main(String[] args) throws InterruptedException {
final ThreadLocalTest test = new ThreadLocalTest();
test.set();
System.out.println(test.getLong());
System.out.println(test.getString());
Thread thread1 = new Thread() {
public void run() {
test.set();
System.out.println(test.getLong());
System.out.println(test.getString());
};
};
thread1.start();
thread1.join();
System.out.println(test.getLong());
System.out.println(test.getString());
/*1
main
11
Thread-0
1
main*/
}
}構造函數
因爲ThreadLocal的作用是提供實例作爲key值，它需要提供的內部變量就是hashcode，而hashcode是由別的方法生成，所以構造函數除了初始化實例外什麼也不做
public ThreadLocal() {
}set
set方法設置當前線程的線程本地變量副本爲指定的值。大部分子類不需要重寫這個方法，只依靠initialValue來設置線程本地變量值。先獲取當前線程中的ThreadLocalMap實例，然後檢查是否爲null。還沒有創建的話需要先新創建一個，將這個ThreadLoca和value值放入map中。
public void set(T value) {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
}
/**
* 獲取關聯ThreadLocal的map。在InheritableThreadLocal中重寫。
*/
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
/**
* 創建一個關聯ThreadLocal的map。在InheritableThreadLocal中重寫。
*/
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}get
get返回這個線程本地變量在當前線程中的副本值。如果這個變量在當前線程中沒有值，第一次通過調用initialValue初始化這個值並返回。
public T get() {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null) {
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
@SuppressWarnings("unchecked")
T result = (T)e.value;
return result;
}
}
return setInitialValue();//map不存在或map中沒有這個對象時調用setInitialValue
}setInitialValue方法是set方法的變體，用於創建初始化值。如果用戶已經重寫了set方法，可以用作set方法的替代。
private T setInitialValue() {
T value = initialValue();//未重寫直接返回null
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
return value;
}initialValue返回此線程局部變量的“初始值”。該方法將在一個線程第一次用get方法訪問變量時被調用，除非線程之前調用了 set方法，在這種情況下， initialValue方法不會被這個線程調用。通常情況下，這種方法是每個線程調用一次，但它可能在後續調用get隨後調用remove而再次調用。這種實現簡單的返回null；如果程序員渴望線程局部變量有一個初始值而不是null，ThreadLocal必須有子類，並重寫這個方法。通常情況下，將使用一個匿名內部類。簡單來說，如果未set這個ThreadLocal的value值而直接調用get會導致在map中添加一個初始化的value值，如果沒有重寫ThreadLocal中的這個方法，那麼初始值是null。
protected T initialValue() {
return null;
}remove
remove方法移除當前線程的線程本地變量值。如果這個線程本地變量隨後被當前線程用get方法讀取，它的值會被initialValue重新初始化，除非這之間當前線程調用了set方法。這可能會導致當前線程中多次調用initialValue方法。
public void remove() {
ThreadLocalMap m = getMap(Thread.currentThread());
if (m != null)//map未初始化時什麼都不做
m.remove(this);
}ThreadLocalMap
ThreadLocalMap是ThreadLocal的內部類，是一個典型的hash表，只適合存儲線程本地變量。沒有操作暴露到ThreadLocal類外部。這個類是包私有的，允許在Thread中聲明字段。爲了幫助解決非常大並且長期存活的使用，hash表條目對key使用WeakReference。然而，因爲沒有使用引用隊列，舊的條目只在表用完空間時才保證移除。
Entry
ThreadLocalMap的條目也是自己實現的。這個hash表的條目擴展了WeakReference，使用它的只要引用字段作爲k(總是ThreadLocal對象)。注意null的key值(比如entry.get() == null)意味着key不再被引用，因此條目可以從表刪除。這樣的條目作爲“舊條目”在下方代碼中被引用。ThreadLocal是弱引用，而value是強引用，如果創建ThreadLocal的線程一直持續運行，那麼這個Entry對象中的value就有可能一直得不到回收，發生內存泄露。
static class Entry extends WeakReference<ThreadLocal<?>> {
/** 關聯這個ThreadLocal的值 */
Object value;
Entry(ThreadLocal<?> k, Object v) {
super(k);//將ThreadLocal作爲key用於構造WeakReference
value = v;
}
}內部變量和構造函數
table是存儲條目的數組，初始大小一定是16
/**
* 初始容量，必需是2的指數次
*/
private static final int INITIAL_CAPACITY = 16;
/**
* 表，有必要的話需要resize。table.length必須總是2的指數次
*/
private Entry[] table;
/**
* 表中條目的數量
*/
private int size = 0;
/**
* 到達後要進行resize的大小
*/
private int threshold; // Default to 0構造函數前面在createMap(Thread, T)中已經提到過，創建一個新的map初始化包含firstKey, firstValue)。ThreadLocalMap是懶漢式構建，因此我們只有當有至少一個條目要放入時再創建一個。負載因子至少是2/3。
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);
}
/**
* 設置resize的門檻保證最差有2/3的負載因子
*/
private void setThreshold(int len) {
threshold = len * 2 / 3;
}還有一個版本是創建一個新的map包含所有來自父map的可繼承的ThreadLocal。只會由createInheritedMap調用。因爲較少使用就不說了。
getEntry
getEntry獲取和key關聯的條目。這個方法本身只處理快速通道：已有key直接命中，否則會轉移到getEntryAfterMiss。這種設計是爲了最大化直接命中的效率，部分通過使這個方法容易非線性讀取來實現。
private Entry getEntry(ThreadLocal<?> key) {
int i = key.threadLocalHashCode & (table.length - 1);//根據hash值計算出直接命中的位置
Entry e = table[i];
if (e != null && e.get() == key)
return e;//命中
else
return getEntryAfterMiss(key, i, e);//未命中
}如果直接目標未命中，需要getEntryAfterMiss來進行線性探測。由於散列的hash值碰撞情況很小，所以比起直接用循環查找的方法效率更高。在線性探測過程中，移動就是最簡單的移動到尾部循環至頭部，如果發現ThreadLocal爲null說明已經被移除，需要刪除這個結點的引用使得可以進行回收。
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;
}
private static int nextIndex(int i, int len) {
return ((i + 1 < len) ? i + 1 : 0);
}hash
剛纔提到了hash和表中對象的關係，那麼要研究下ThreadLocalMap的hash值是怎麼設計的。首先，要明確的一點是ThreadLocalMap使用的是開放地址法線性探測解決hash碰撞的問題，而hash值是在ThreadLocal中的。我們可以看到ThreadLocal中跟hash值計算有關的部分，用一個AtomicInteger來計算，是static也就是說有一個靜態的值每新建一個ThreadLocal實例就會增加，但增加的間隔並不是1，而是0x61c88647，這個值得選取是爲了減少碰撞的發生，具體原理和斐波那契散列法以及黃金分割有關。 所以，對於同樣的ThreadLocal變量，各線程的ThreadLocalMap中它們都處於同一個數組位置。因此，還是建議每個線程只存一個變量，這樣的話所有的線程存放到map中的Key都是相同的ThreadLocal，如果一個線程要保存多個變量，就需要創建多個ThreadLocal，多個ThreadLocal放入Map中時會極大的增加hash衝突的可能。如果必須使用多個變量，0x61c88647可以儘可能減少衝突的發生。因爲表的大小永遠是2的指數次，所以和len-1進行位與操作等價爲直接取模。
/**
* ThreadLocal依賴每個線程線性探測hash表關聯到每個線程(Thread.threadLocals和inheritableThreadLocals)。
* ThreadLocal對象作爲key，通過threadLocalHashCode來查找。
* 這是一個典型的hash值(只在ThreadLocalMaps內有用)消除當同樣的線程連續創建ThreadLocal實例常見狀況下的衝突，同時不太常見的狀況也是良性的。
*/
private final int threadLocalHashCode = nextHashCode();
/**
* 下一個要給出的hash值，自動更新，從0開始。
*/
private static AtomicInteger nextHashCode =
new AtomicInteger();
/**
* 連續產生的hash值之間的差值-使得連續的線程本地ID變得隱式連續，接近最佳地擴展到大小是2的指數次表的乘法倍數的hash值上。
*/
private static final int HASH_INCREMENT = 0x61c88647;//0110 0001 1100 1000 1000 0110 0100 0111
/**
* 返回下一個hash值
*/
private static int nextHashCode() {
return nextHashCode.getAndAdd(HASH_INCREMENT);
}set
set沒有像get那樣使用快速路徑是因爲使用set創建一個新的條目至少和替換一個已有的是一樣頻率，這樣快速路徑會經常失敗。set會從hash對應的位置開始線性查找指定的key值，如果找到entry存在但key爲null的位置說明已經被remove，使用replaceStaleEntry替換過時的值。如果找到了這個key值則替換已有值。如果找到了entry爲null的位置說明還未被使用過，直接新建一個entry放到這個位置上。
private void set(ThreadLocal<?> key, Object value) {
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)]) {
ThreadLocal<?> k = e.get();
if (k == key) {
e.value = value;//替換已有值
return;
}
if (k == null) {
replaceStaleEntry(key, value, i);//替換過時的值
return;
}
}
tab[i] = new Entry(key, value);//hash值對應的位置沒有插入過元素
int sz = ++size;
if (!cleanSomeSlots(i, sz) && sz >= threshold)
rehash();
}replaceStaleEntry用一個有指定key的條目替換在set操作中遇到的過時條目。value參數傳遞的值存儲在條目中，無論有這個key的條目是否已經存在。作爲一個副作用，這個方法擦除了一趟中所有過時的條目(一趟指兩個entry爲null位置間的序列)。新的條目放在staleSlot位置上，而從這個位置開始向前和向後倒兩個entry爲null的位置之間所有key爲null的條目都會被清除。
private void replaceStaleEntry(ThreadLocal<?> key, Object value,
int staleSlot) {
Entry[] tab = table;
int len = tab.length;
Entry e;
//返回檢查當前趟中之前的過期條目。我們一次清除整個趟避免因爲垃圾回收釋放串中的引用而頻繁增加的rehash
int slotToExpunge = staleSlot;
for (int i = prevIndex(staleSlot, len);
(e = tab[i]) != null;
i = prevIndex(i, len))//從staleSlot開始向前直到entry爲null的位置爲止最靠前的引用爲null的條目
if (e.get() == null)
slotToExpunge = i;
//尋找key或者趟裏後面null位置兩者中先發生的
for (int i = nextIndex(staleSlot, len);
(e = tab[i]) != null;
i = nextIndex(i, len)) {//循環從staleSlot向後倒entry爲null的位置
ThreadLocal<?> k = e.get();
//如果找到key，我們需要交換它和過期條目來保持hash表順序。新的過期位置或者在它之前任何其他過期位置，
//可以被髮送給expungeStaleEntry來移除或者rehash趟中的其他所有條目
if (k == key) {//找到了set操作中要插入的key
e.value = value;
tab[i] = tab[staleSlot];//將key相同的結點與staleSlot位置的結點交換
tab[staleSlot] = e;
// 如果有的話開始擦除先前的過期結點
if (slotToExpunge == staleSlot)
slotToExpunge = i;
cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);//第一個參數是從slotToExpunge到下一個null的位置，第二個參數是table長度
return;
}
//向前查找沒有找到過期條目，在查找key時第一個發現的過期條目還是趟中的第一個
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);
}expungeStaleEntry通過rehash任何在staleSlot與下一個null位置之間可能衝突條目來擦除過期條目。這也擦除了在隨後的null之前遇到的所有其他過期條目。返回staleSlot之後下一個null的位置(在staleSlot和這個位置之間的都被檢查是否要擦除)。
private int expungeStaleEntry(int staleSlot) {
Entry[] tab = table;
int len = tab.length;
// 擦除在staleSlot的條目
tab[staleSlot].value = null;
tab[staleSlot] = null;
size--;
// 直到遇到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) {//key爲null說明已經被remove，刪除其他數據
e.value = null;
tab[i] = null;
size--;
} else {//key存在，移動到接近hash直接定位的地方
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;
}cleanSomeSlots檢查log2(n)個位置，除非找到了一個過期條目，額外檢查log2(table.length)-1個位置。插入時調用這個參數是元素個數，replaceStaleEntry調用時這個參數是table的大小。
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);//n=n/2
return removed;
}set在新增一個條目到沒有使用過的位置時，導致size增加，同時會觸發rehash。會清空所有過期的條目，並根據size大小判斷是否需要擴大數組，如果要擴大數組則數組大小*2。
private void rehash() {
expungeStaleEntries();
// Use lower threshold for doubling to avoid hysteresis
if (size >= threshold - threshold / 4)
resize();//size達到了resize的大小，擴大數組
}
/**
* 兩倍擴大表
*/
private void resize() {
Entry[] oldTab = table;
int oldLen = oldTab.length;
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();
if (k == null) {
e.value = null; // Help the GC
} else {
int h = k.threadLocalHashCode & (newLen - 1);
while (newTab[h] != null)
h = nextIndex(h, newLen);
newTab[h] = e;
count++;
}
}
}
setThreshold(newLen);
size = count;
table = newTab;
}
/**
* 清除表中穩定所有過期條目
*/
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);
}
}
}remove
移除key對應的條目，直接通過線性探測法找到對應的key值，條目調用clear()方法後key會變爲null但條目仍然存在，通過expungeStaleEntry(int)將table中這個位置置爲null，並且gc可以回收這個條目。當線程終止時，它的ThreadLocal對象引用會變爲null，那麼在後續使用中table中不再有引用的條目會被垃圾回收，但是如果線程長時間存活但ThreadLocal對象不再被使用，需要顯示的調用remove方法，避免內存泄漏。
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)]) {//線性查找hash值相等的條目
if (e.get() == key) {
e.clear();//清除引用
expungeStaleEntry(i);//刪掉過期條目
return;
}
}
}