ThreadLocalMap源碼分析

分析ThreadLocalMap源碼的原因，是想看看使用WeakReference的類似Map數據結構是如何銷燬已被回收的WeakReference指向的對象。瞭解銷燬的算法，學習其思路，以備以後自己開發類似功能。

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

    Entry(ThreadLocal<?> k, Object v) {
        super(k);
        value = v;
    }
}

Entry[] table; // 這是ThreadLocalMap保存數據的地方。

table[i].get()；獲取的是WeakReference指向的值，而不是value。這個值會在除WeakReference外，沒有其他引用指向的時候，被JVM回收。

問題提出：
如果WeakReference指向的值，即ThreadLocal，被JVM回收後（常見是，在Thread結束後的一次gc）。table不錯陳舊數據處理，會怎麼樣？答案是table無限增大，效率隨時間的增長不斷的降低。如何高效的回收，是學習的重點。

private int expungeStaleEntry(int staleSlot)；如果發現table一個slot，使得table[slot].get() == null。表明數據陳舊，需回收。調用該方法。
代碼：

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

不僅將當前slot的Entry置空，還要檢查slot到下一個爲null的slot之間的entry。如果爲陳舊的數據，則置空。如果不是，進行rehash。
rehash的原理是：int h = k.threadLocalHashCode & (len - 1); h!=i，表明當初在新增的時候，就發生了hash衝突，導致該entry在table的位置後移。處理方式是：將tab[i]=null，重新找index爲h及之後的table，直道找到table[h]=null，然後將table[h] = e。hash衝突會隨後介紹。
返回值是下一個table[slot]==null的slot；

private boolean cleanSomeSlots(int i, int n)。這個函數實際是調用expungeStaleEntry清除陳舊數據的。
代碼：

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

比較有意思的是這句：while ( (n >>>= 1) != 0); 循環log2(n)次，目的是平衡不做清除（高效但是陳舊數據殘留）和全部判斷並做清除（對一些插入操作性能造成影響）。這種做法目前挺高效，並且工作挺不錯，所以就用着了。
if (e != null && e.get() == null) { n = len; 意味着一旦發現有陳舊數據，循環次數將增加。
返回值，是否有陳舊值被清除。

private void set(ThreadLocal

private void set(ThreadLocal<?> key, Object value) {

    // We don't use a fast path as with get() because it is at
    // least as common to use set() to create new entries as
    // it is to replace existing ones, in which case, a fast
    // path would fail more often than not.

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

有了上面的介紹，這段就很好理解了。replaceStaleEntry(key, value, i);這句以後再研究，有點複雜（向前去除陳舊數據）。
這句有點意思：
if (!cleanSomeSlots(i, sz) && sz >= threshold) rehash(); 如果有陳舊值被處理，那麼一定不會進行rehash。如果沒有陳舊值被刪除，則看當前table的entry數量是否大於閾值。是，則rehash。

private void rehash() {
    expungeStaleEntries();

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

清除所有陳舊值，然後resize。

rezie()有點意思，處理hash衝突的方式和HashMap不一樣。
代碼：

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

將新的table大小設爲舊的table大小的2倍。然後將舊的table中entry挨個插入到新的table中，當然，插入前還是要判斷entry是否過期。
插入過程中，如果發現hash衝突（int h = k.threadLocalHashCode & (newLen - 1); ），則查找h之後的table元素，知道table[h] != null，將table[h] = e；
這應該是另一種hash探測法吧，還得找時間學學。

對比WeakHashMap，大致原理與ThreadLocalMap相似。
WeakHashMap執行expungeTableEntries()是在resize(), size(), getTable()等方法中。而不是在每一次插入。