ThreadLocal-526互联

`ThreadLocal`详解

`ThreadLocalMap.set()`

通过hash计算后的槽位对应的Entry数据为空，直接将数据放到槽位即可。并对当前位置进行启发式清理。
槽位数据不为空，key值与当前ThreadLocal通过hash计算获取的key值一致，则直接更新该槽位的数据

若当前槽位数据过期，则执行replaceStaleEntry(key, value, i)步骤。

replaceStaleEntry(key, value, i) 方法步骤
1.向前寻找最前面的过期槽位的位置，并用slotToExpunge记录，一直到槽位为空为之。
2.向后寻找是否有槽位的key与当前要插入的key相同：
	1.如果有则将插入的值放入找到的槽位i，并将槽位i与staleSlot的值交换。然后从slotToExpunge记录的最前面的过期数据的位置开始线性清理，将线性清理的返回值位置再进行启发式清理。返回。
	2.如果没有new一个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);
    int sz = ++size;
    if (!cleanSomeSlots(i, sz) && sz >= threshold)
        rehash();
}

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

`ThreadLocalMap.get()`

通过将key 进行hash得到数据的在散列表中的位置slot，如果slot位置中的Entry的key和查找的key一致，则直接返回。

若不一致，则继续往后查找。查找过程中若遇到过期key，则进行探测式清理。然后继续从当前位置往后找，直到Entry为空，为空则返回null。

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

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

探测式清理

从传入位置一直往后找，遇到过期数据，就将value 置为空，遇到未过期数据就计算hash，看当前位置有没有便宜，如果偏移，则从本应在的位置向后查找，遇空位置即放元素(rehash)。即：对未过期的Entry的key进行rehash。

private int expungeStaleEntry(int staleSlot) {
    Entry[] tab = table;
    int len = tab.length;
    tab[staleSlot].value = null;
    tab[staleSlot] = null;
    size--;
    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;
}

启发式清理

从探测式清理函数传进来的地址进行启发式清理。清理范围为\(log_2len\),即：从当前位置向后查找\(log_2len\)个位置，遇到过期数据再进行探测式清理。

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

`ThreadLocalMap`扩容机制

set()方法中若清理掉任何过期元素，且size >= threshold会进行rehash()逻辑,在rehash()中进行判断是否需要扩容。
在探测清理的rehash()过程中，若size >=- threshold - threshold / 4 会进行扩容。

private void rehash() {
    expungeStaleEntries();  // 先进行一次探测清理
    if (size >= threshold - threshold / 4)
        resize();
}

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

扩容后的tab大小为原来的两倍，扩容的过程就是遍历原来的hash表，对每个元素重新计算hash，并放到新的hash表中。

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