【JUC原始碼】ThreadLocal原始碼深析&使用示例

在開始看原始碼之前，我們必須要知道ThreadLocal有什么作用：ThreadLocal 使同一個變數在不同執行緒間隔離，即每個執行緒都可以有自己獨立的副本，然后可以在該執行緒的方法間共享（隨時取出使用），不明白的話可以看文章第三部分的使用示例，

這其實是一種空間換時間的思路，因為如果每個執行緒都有自己獨立的副本，就不用通過加鎖使執行緒串行化執行去保證執行緒安全了，節省了時間，但作為代價要為每個執行緒開辟一塊獨立的空間，

了解了 ThreadLocal 的功能后，那我們該如何設計ThreadLocal？

1.如何設計執行緒間隔離

首先，很容易想到每個執行緒都必須為 ThreadLocal 開辟一塊單獨的記憶體，但僅僅開辟一塊大小等于ThreadLocal的記憶體是不夠的的，因為一個執行緒可能有多個獨立的副本，換句話說就是可以在多個類中創建 ThreadLocal，比如：

public class A {
	private static ThreadLocal<String> threadLocal1 = new ThreadLocal<>();
	
	public void f1(){ threadLocal1.set("test");
}
public class B {
	private static ThreadLocal<Integer> threadLocal2 = new ThreadLocal<>();

	public void f2(){ threadLocal1.set(001);
}

那么對于執行的執行緒來說，test和001都是它的獨立副本，都要保存起來，而他倆的區別就在于具體ThreadLocal物件不同，

接下來，我們就看看在執行緒(Thread類)中到底是如何保存ThreadLocal的：

可以看到，每個Thread維護一個ThreadLocalMap，而存盤在ThreadLocalMap內的就是一個以Entry為元素的table陣列（Entry就是一個key-value結構：key為ThreadLocal，value為存盤的值），所以我們可以得到以下兩點資訊：

1. 陣列保證了每個執行緒可以存盤多個獨立的副本
2. Entry 提供了區分不同副本方式，即ThreadLocal不同

另外，雖然這里有兩個變數，但只有 threadLocals 是直接進行set/get操作的，若在父執行緒中創建子執行緒，會拷貝父執行緒的inheritableThreadLocals到子執行緒，

看原始碼前的要理解的邏輯終于說完了，下面進入正戲…

2.ThreadLocal

ThreadLocal 核心成員變數及主要建構式：

// ThreadLocal使用了泛型，所以可以存放任何型別
public class ThreadLocal<T> {
    
    // 當前 ThreadLocal 的 hashCode，作用是計算當前 ThreadLocal 在 ThreadLocalMap 中的索引位置
    // nextHashCode() { return nextHashCode.getAndAdd(HASH_INCREMENT);}
    private final int threadLocalHashCode = nextHashCode();
   
    // nextHashCode 直接決定 threadLocalHashCode（= nextHashCode++）
    // 這么做因為ThreadLocal可能在不同類中new出來多個，但執行緒只有一個，若每次下標都從同一位置開始，雖然有hash碰撞處理策略，但仍然會影響效率
    // static：保證了nextHashCode的唯一性，間接保證了threadHashCode唯一性
    private static AtomicInteger nextHashCode = new AtomicInteger();
    
    static class ThreadLocalMap{...}
    
    // 只有空參構造
    public ThreadLocal() {
    }
	
	// 計算 ThreadLocal 的 hashCode 值，就是通過CAS讓 nextHashCode++
	private static int nextHashCode() {
    	return nextHashCode.getAndAdd(HASH_INCREMENT);
	}
	
	//......
}

2.1 set()

拿到當前執行緒的 threadLocals 并將 Entry(當前ThreadLocal物件，value）放入，另外，因為 set 操作每個執行緒都是串行的，所以不會有執行緒安全的問題

public void set(T value) {
    // 拿到當前執行緒
    Thread t = Thread.currentThread();
    // 拿到當前執行緒的ThreadLocalMap，即threadLocals變數
    ThreadLocalMap map = getMap(t);
    
    // 當前 thradLocal 非空，即之前已經有獨立的副本資料了
    if (map != null)
        map.set(this, value); // 直接將當前 threadLocal和value傳入
    // 當前threadLocal為空
    else
        createMap(t, value); // 初始化ThreadLocalMap
}

ThreadLocalMap getMap(Thread t) {
    return t.threadLocals;
}

2.2 get()

在當前執行緒的 theadLocals 中獲取當前ThreadLocal物件對應的value

1. 在當前執行緒拿到threadLocals
2. 若threadLocals=null，則將其初始化
3. 通過當前ThreadLocal物件獲取到相應Entry
   • entry != null ，回傳result
   • entry = null ，回傳null

public T get() {
    // 拿出當前執行緒
    Thread t = Thread.currentThread();
    // 從執行緒中拿到 threadLocals(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;
        }
    }
    // 否則給當前執行緒的 ThreadLocal 初始化，并回傳初始值 null
    return setInitialValue();
}

3.ThreadLocalMap

• 雖然是內部類，但 ThreadLocalMap 不像 List 的 Node 是 List 的組成部分（List > Node)
• ThreadLocalMap是用來給Thread作為屬性，并保存ThreadLocal的 (Thread > ThreadLocalMap > ThreadLocal)

// 靜態內部類,可直接被外部呼叫
static class ThreadLocalMap {
        // Entry(k,v)
    	// k = WeakReference 是弱參考，當沒有參考指向時，會直接被回收
        static class Entry extends WeakReference<ThreadLocal<?>> {
            // 當前 ThreadLocal 關聯的值
            Object value;
            // WeakReference 的參考 referent 就是 ThreadLocal
            Entry(ThreadLocal<?> k, Object v) {
                super(k);
                value = v;
            }
        }
    	
    	// 存盤 (ThreadLocal,Obj) 的陣列
        private Entry[] table;
        // 陣列的初始化大小
        private static final int INITIAL_CAPACITY = 16; 
        // 擴容的閾值，默認是陣列大小的三分之二
        private int threshold;
		
		//.......
}

3.1 set()

將 Entry（threadLocal，Object Value）放入 threadLocals的陣列

1. 獲取到 threadLocals 的陣列
2. 計算當前ThreadLocal對應的陣列下標
3. 將Entry（threadLocal，Object Value）放入陣列
   • 無hash碰撞，new Entry放入
   • 若出現hash碰撞，則i++，直到找到沒有Entry的位置，new Entry放入
   • 若碰見key相同（ThreadLocal），則替換value
4. 判斷是否需要擴容

private void set(ThreadLocal<?> key, Object value) {
    // 1.拿到當前threadLocals的陣列
    Entry[] tab = table;
    int len = tab.length;
    // 2.計算當前 ThreadLocal 在陣列中的下標，其實就是 ThreadLocal 的 hashCode 和陣列大小-1取余
    int i = key.threadLocalHashCode & (len-1);
	
	// 可以看到回圈的結束條件是 tab[i]==null，即無哈希沖突
	// 若出現哈希沖突時，依次向后（i++）尋找空槽點，nextIndex方法就是讓在不超過陣列長度的基礎上，把陣列的索引位置 + 1
    for (Entry e = tab[i]; e != null; e = tab[i = nextIndex(i, len)]) {
        ThreadLocal<?> k = e.get();
        // 找到記憶體地址一樣的 ThreadLocal，直接替換
        if (k == key) {
            e.value = value;
            return;
        }
        // 當前 key 是 null，說明 ThreadLocal 被清理了，直接替換掉
        if (k == null) {
            replaceStaleEntry(key, value, i);
            return;
        }
    }
    // 當前 i 位置是無值的，可以被當前 thradLocal 使用
    tab[i] = new Entry(key, value);
    int sz = ++size;
    
    // 當陣列大小大于等于擴容閾值(陣列大小的三分之二)時，進行擴容
    if (!cleanSomeSlots(i, sz) && sz >= threshold)
        rehash();
}

3.2 getEntry()

獲取相應節點Entry

1. 計算當前ThreadLocal對應的索引位置（hashcode 取模陣列大小-1 ）
2. 若 e != null，回傳當前Entry
3. 若 e == null 或 有但key(ThreadLocal)不符，呼叫 getEntryAfterMiss 自旋進行尋找

private Entry getEntry(ThreadLocal<?> key) {
    // 計算索引位置：ThreadLocal 的 hashCode 取模陣列大小-1
    int i = key.threadLocalHashCode & (table.length - 1);
    Entry e = table[i];
    
    // e 不為空 && e 的 ThreadLocal 的記憶體地址和 key 相同
    if (e != null && e.get() == key)
        return e; // 直接回傳
    // 因為上面解決Hash沖突的方法是i++，所以會出現計算出的槽點為慷訓者不等于當前ThreadLocal的情況
    else
        return getEntryAfterMiss(key, i, e); // 繼續通過 getEntryAfterMiss 方法找
}

getEntryAfterMiss：根據 thradLocalMap set 時解決陣列索引位置沖突的邏輯，該方法的尋找邏輯也是對應的，即自旋 i+1，直到找到為止

private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
    Entry[] tab = table;
    int len = tab.length;
    // 在大量使用不同 key 的 ThreadLocal 時，其實還蠻耗性能的
    while (e != null) {
        ThreadLocal<?> k = e.get();
        // 記憶體地址一樣，表示找到了
        if (k == key)
            return e;
        // 洗掉沒用的 key
        if (k == null)
            expungeStaleEntry(i);
        // 繼續使索引位置 + 1
        else
            i = nextIndex(i, len);
        e = tab[i];
    }
    return null;
}

3.3 resize()

ThreadLocalMap 中的 ThreadLocal 的個數超過閾值時，ThreadLocalMap 就要開始擴容了

1. 拿到threadLocals的table
2. 初始化新陣列，大小為原來2倍
3. 將老陣列拷貝到新陣列
   • 根據key（ThreadLocal）計算新的索引位置
   • 若出現hash碰撞，i++
4. 計算新的擴容閾值，將新陣列賦給table

private void resize() {
    // 1.拿出舊的陣列
    Entry[] oldTab = table;
    int oldLen = oldTab.length;
    // 2.計算新陣列的大小，為老陣列的兩倍
    int newLen = oldLen * 2;
    // 初始化新陣列
    Entry[] newTab = new Entry[newLen];
    int count = 0;
    
    // 3.老陣列的值拷貝到新陣列上
    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 {
                // 計算 ThreadLocal 在新陣列中的位置
                int h = k.threadLocalHashCode & (newLen - 1);
                // 如果出現哈希沖突，即索引 h 的位置值不為空，往后+1，直到找到值為空的索引位置
                while (newTab[h] != null)
                    h = nextIndex(h, newLen);
                // 給新陣列賦值
                newTab[h] = e;
                count++;
            }
        }
    }
    // 4.計算新陣列下次擴容閾值，為陣列長度的三分之二
    setThreshold(newLen);
    size = count;
    table = newTab;
}

4.使用示例

下面啟動 9 個子執行緒，每個子執行緒都將名字（thread - i）存在同一個變數中，然后再列印出來，可以想到，如果同一個變數可以做到執行緒間隔離（互補影響），控制臺正確的結果應該是 thread - 0 到 thread - 8，

下面就分別演示演示這個變數的兩種實作：1.普通變數String ，2.ThreadLocal<String>

4.1 普通變數

public class StringTest {
	// 保存執行緒名的普通變數value
    private String value;
	// 不直接設定value，而是暴露出get和set方法
    private String getString() { return string; }
    private void setString(String string) { this.string = string; }

    public static void main(String[] args) {
    
        StringTest test= new StringTest ();
        
        int threads = 9; // 要啟動的執行緒個數
        CountDownLatch countDownLatch = new CountDownLatch(threads); // countDownLatch 用于防止主執行緒在子執行緒未完成前結束
       
        // 啟動9個子執行緒
        for (int i = 0; i < threads; i++) {
            Thread thread = new Thread(() -> {
                test.setString(Thread.currentThread().getName()); // 向變數value中存入執行緒名 thread - i
                System.out.println(test.getString()); // 然后列印出來，注：這里可能存在并發
                countDownLatch.countDown(); // 門栓-1
            }, "thread - " + i); 
            thread.start();
        }
    }

	countDownLatch.await(); // 等countDownLatch為0時，主執行緒恢復運行
}

結果如下：

thread - 1
thread - 2
thread - 1
thread - 3
thread - 4
thread - 5
thread - 6
thread - 7
thread - 8

可以看到沒有 thread - 0，反而 thread - 1 出現了兩次，所以使用普通型別的變數無法實作同一變數對于不同執行緒隔離

4.2 ThreadLocal

使用ThreadLocal時，一般宣告為static

• 一個類一個ThreadLocal–> 當前執行緒一個Entry 就夠了
• 使用時呼叫方便

public class ThreadLocalStringTest {
	// 保存執行緒名的ThreadLocal變數threadLocal
	// 注：這里除了是String，也可是別的任何型別（Integer，List，Map...）
    private static ThreadLocal<String> threadLocal = new ThreadLocal<>();
	// 不直接操作 threadLocal，而是封裝成 set/get 方法
    private String getString() { return threadLocal.get(); }
    private void setString(String string) { threadLocal.set(string);}

    public static void main(String[] args) {
    
        ThreadLocalStringTest test= new ThreadLocalStringTest();
        
        int threads = 9; // 要創建的子執行緒個數
        CountDownLatch countDownLatch = new CountDownLatch(threads); // countDownLatch 用于防止主執行緒在子執行緒未完成前結束
		
        // 創建 9 個執行緒
        for (int i = 0; i < threads; i++) {
            Thread thread = new Thread(() -> {
                test.setString(Thread.currentThread().getName()); // 向ThreadLocal中存入當前執行緒名 thread - i
                System.out.println(test.getString()); // 向ThreadLocal獲取剛存的執行緒名，注：可能存在并發
                countDownLatch.countDown(); // 門栓-1
            }, "thread - " + i);
            thread.start();
        }
		
		countDownLatch.await(); // 等countDownLatch為0時，主執行緒恢復運行
    }

}

運行結果：

thread - 0
thread - 1
thread - 2
thread - 3
thread - 4
thread - 5
thread - 6
thread - 7
thread - 8

可以看到運行結果符合預期，即ThreadLocal實作了同一變數在執行緒間隔離，另外ThreadLocal還可以用于單點登錄，用來保存不同請求執行緒的token，然后在決議時取出，