【JAVA】ThreadLocal源碼分析

ThreadLocal內部是用一張哈希表來存儲：

static class ThreadLocalMap {
    static class Entry extends WeakReference<ThreadLocal<?>> {
            /** The value associated with this ThreadLocal. */
            Object value;

            Entry(ThreadLocal<?> k, Object v) {
                super(k);
                value = v;
            }
    }
    private static final int INITIAL_CAPACITY = 16;
    private Entry[] table;
    private int size = 0;
    private int threshold;
    ......

看過HashMap的話就很容易理解上述內容【Java】HashMap源碼分析

而在Thread類中有一個ThreadLocalMap 的成員：

ThreadLocal.ThreadLocalMap threadLocals = null;

所以不難得出如下關系：

每一個線程都有一張線程私有的Map，存放多個線程本地變量

set()方法：

public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
}

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

不難看出，先獲取當前線程的Thread對象，再得到該Thread對象的ThreadLocalMap 成員map，若map為空，需要先createMap()方法，若不為空，則需要調用map的set()方法

void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
}
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);
}
private void setThreshold(int len) {
            threshold = len * 2 / 3;
}

createMap方法會創建一個ThreadLocalMap對象，在ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue)構造方法中，可以看出和HashMap很相似，通過firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1)取模，計算出哈希表的下標，將創建好的Entry對象放入該位置，再根據表長計算閾值，可以看出負載因子是2/3，初始哈希表的大小是16。

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);
    int sz = ++size;
    if (!cleanSomeSlots(i, sz) && sz >= threshold)
        rehash();
}

不難看出，通過key.threadLocalHashCode & (len-1)計算出哈希表的下標，判斷該位置的Entry是否為null，若為null，則創建Entry對象，將其放入該下標位置；若Entry已存在，則需要解決哈希沖突，重新計算下標。最后size自增，再根據!cleanSomeSlots(i, sz) && sz >= threshold進行判斷是否需要進行哈希表的調整。

在解決哈希沖突的上，常用的有開鏈法、線性探測法和再散列法，HashMap中使用的是開鏈法，而ThreadLocal使用的是線性探測法，即發生哈希沖突，往后移動到合適位置。

private static int nextIndex(int i, int len) {
            return ((i + 1 < len) ? i + 1 : 0);
}
private static int prevIndex(int i, int len) {
            return ((i - 1 >= 0) ? i - 1 : len - 1);
}

從這兩個操作看出，ThreadLocal中的哈希表是利用了循環數組的方式，進行環形的線性探測
在上述for循環中，會取出該Entry上的ThreadLocal對象（鍵）進行判斷，若相同則直接覆蓋，若為null，說明該Entry空間存在但其ThreadLocal對象的指向為null，需要進行調整；若都不成立，則繼續循環，重復以上操作。

Entry空間指向存在但ThreadLocal對象的指向為null是因為Entry繼承自WeakReference<ThreadLocal<?>>，是弱引用，存在被GC的情況，所以會存在這種情況，視為臟Entry，接下來的操作就是通過replaceStaleEntry進行處理。

private void replaceStaleEntry(ThreadLocal<?> key, Object value,
                                       int staleSlot) {
    Entry[] tab = table;
    int len = tab.length;
    Entry e;
    
    int slotToExpunge = staleSlot;
    for (int i = prevIndex(staleSlot, len);
         (e = tab[i]) != null;
         i = prevIndex(i, len))
        if (e.get() == null)
            slotToExpunge = i;
            
    for (int i = nextIndex(staleSlot, len);
         (e = tab[i]) != null;
         i = nextIndex(i, len)) {
        ThreadLocal<?> k = e.get();
    
        if (k == key) {
            e.value = value;
    
            tab[i] = tab[staleSlot];
            tab[staleSlot] = e;
    
            if (slotToExpunge == staleSlot)
                slotToExpunge = i;
            cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
            return;
        }
    
        if (k == null && slotToExpunge == staleSlot)
            slotToExpunge = i;
    }
    
    tab[staleSlot].value = null;
    tab[staleSlot] = new Entry(key, value);
    
    if (slotToExpunge != staleSlot)
        cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
}

可以清楚看到第一個for循環前向遍歷查找臟Entry，用slotToExpunge保存臟Entry下標；
第二個for循環后向遍歷，若遇到ThreadLocal向同，更新value，然后與下標為staleSlot（傳入進來的臟Entry）進行交換，接着判斷前向查找臟Entry是否存在，slotToExpunge == staleSlot說明的就是前向查找沒找到，就更改slotToExpunge的值，然后進行清理操作，結束掉；若后向遍歷遇到臟Entry，並且前向沒找到，更改slotToExpunge的值，為清理時用，繼續循環。
若不存在和ThreadLocal引用相同的Entry，則需要將staleSlot的位置的Entry替換為一個新的Entry對象，tab[staleSlot].value = null是為了GC；
最后根據slotToExpunge來判斷前向后向遍歷中是否存在臟Entry，若存在還需要進行清理。

其中的expungeStaleEntry方法如下：

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;
}

可以看到，先把當前位置的臟Entry清除掉（置為null），size自減。然后從當前位置后向遍歷，若遇到臟Entry直接清除，size自減；若不是臟Entry，則需要判斷它是否經過哈希沖突的調整的，若調整過，需要將其重新調整，最后返回當前位置為null的table下標；綜上，該方法就是后向清除臟Entry，再把調整需要調整的Entry。

在replaceStaleEntry方法中，調用expungeStaleEntry清除掉臟Entry后，還要用cleanSomeSlots方法清除掉返回回來的下標后的臟Entry；

cleanSomeSlots方法：

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后面的開始后向遍歷，遇到臟Entry調用expungeStaleEntry清除掉，令removed為true，i會變為下標為null的位置，繼續循環；其中n的用途是控制循環次數，當遇到臟Entry時，會令n等於表長，擴大搜索范圍。

在set方法中，最后根據!cleanSomeSlots(i, sz) && sz >= threshold，判斷是否清理掉了臟Entry，若清理了什么都不做；若沒有清理，還會判斷是否達到閾值，進而是否需要rehash操作；

rehash方法：

private void rehash() {
    expungeStaleEntries();
    
    // Use lower threshold for doubling to avoid hysteresis
    if (size >= threshold - threshold / 4)
        resize();
}

首先調用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);
    }
}

可以看到expungeStaleEntries方法是遍歷整個哈希表，通過調用expungeStaleEntry方法清除掉所有臟Entry。
由於清除掉了臟Entry，還需要對size進行判斷，看是否達到了閾值的3/4（提前觸發resize），來判斷是否真的需要resize；

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;
}

剛開始的操作可以清楚的明白，每次擴容的大小都是原來的兩倍；然后遍歷原表的所有Entry，遇到臟Entry直接賦值null引起幫助GC；遇到有效Entry則需要根據新的表長重新計算下標，再通過線性探測完成新表的填充；填充完畢，計算新的閾值，給size和table賦值，結束操作。

至此，有關set的操作就結束了，還剩下get和remove：

get方法:

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();
}

和set一樣，先獲取當前線程，再根據當前線程獲取其ThreadLocalMap成員map；
若map不為null，通過map的getEntry方法得到Entry對象，若Entry不為null則直接返回Entry的value；
若map為null，或者map不為null，但是Entry是null，則都需要調用setInitialValue方法。

getEntry方法：

private Entry getEntry(ThreadLocal<?> key) {
    int i = key.threadLocalHashCode & (table.length - 1);
    Entry e = table[i];
    if (e != null && e.get() == key)
        return e;
    else
        return getEntryAfterMiss(key, i, e);
}

根據ThreadLocal定位哈希表的下標，若滿足則直接返回，若不是，調用getEntryAfterMiss繼續找。

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;
}

看以看到這還是一個后向遍歷的查找，若是找到則直接返回；若遇到臟Entry需要調用expungeStaleEntry方法清理掉；最后還沒找到返回null。

setInitialValue方法：

private T setInitialValue() {
    T value = initialValue();
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
       map.set(this, value);
    else
       createMap(t, value);
    return value;
}

先調用initialValue方法，該方法需要使用者進行覆蓋，否則返回的是null。所以當沒有使用set方法時覆蓋initialValue方法時還是會調用set方法的，效果是一樣的。

protected T initialValue() {
        return null;
}

后面的操作就和set方法一樣。get方法至此結束。

remove方法：

public void remove() {
    ThreadLocalMap m = getMap(Thread.currentThread());
    if (m != null)
        m.remove(this);
}

以當前線程為參數調用getMap方法：

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

若是當前線程的ThreadLocalMap對象不存在，什么都不做，若存在，調用內部的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)]) {
        if (e.get() == key) {
            e.clear();
            expungeStaleEntry(i);
            return;
        }
    }
}

首先根據ThreadLocal找到其對應的的哈希表的下標（不一定是它的下標，會有哈希沖突的可能性），然后開始后向遍歷，找到真正的位置，調用clear方法刪除掉，順便還進行臟Entry的清理。

clear方法是Reference類的方法：

public void clear() {
    this.referent = null;
}

可以看到僅僅只是令指向變為null，因為Reference是WeakReference的父類，ThreadLocalMap繼承自WeakReference<ThreadLocal<?>>，弱引用變為null，就會變成臟Entry，所以就需要expungeStaleEntry對其清理。為什么不令tab[i]直接為null，就是因為在expungeStaleEntry執行時還會清理遇到的臟Entry，這樣可以盡可能多的刪除掉臟Entry。

ThreadLocal源碼分析到此結束。