ThreadLocal

ThreadLocal详解

ThreadLocalMap.set()

1. 通过hash计算后的槽位对应的Entry数据为空，直接将数据放到槽位即可。并对当前位置进行启发式清理。

2. 槽位数据不为空，key值与当前ThreadLocal通过hash计算获取的key值一致，则直接更新该槽位的数据

3. 若当前槽位数据过期，则执行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()

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

2. 若不一致，则继续往后查找。查找过程中若遇到过期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;
}