Java ThreadLocalMap静态内部类

版本
JDK8(JDK1.8)

ThreadLocalMap静态内部类总结

1.ThreadLocalMap是ThreadLocal类的静态内部类，是用于实现其功能的数据结构

ThreadLocal类源码可以看我这篇文章 ThreadLocal

2.ThreadLocalMap类里面有个最核心的结构是Entry数组，Entry类是一个键值对，其键是弱引用类型，值是强引用类型，有内存泄漏的问题，可以看上面ThreadLocal类那篇文章有详细讲解

ThreadLocalMap的实现

ThreadLocalMap构成

1. INITIAL_CAPACITY是初始容量，且必须是2的幂。
2. 可以看出ThreadLocalMap由Entry数组table构成
3. size是ThreadLocalMap中存放的有效Entry键值对个数
4. threshold是阈值，当size到达阈值，会发生Entry数组扩容

static class ThreadLocalMap {
        private static final int INITIAL_CAPACITY = 16;
        private Entry[] table;
        private int size = 0;
        private int threshold;
}

Entry键值对

1. Entry的键是ThreadLocal，Entry的值是value,Entry的键为什么没出现在类里面，是因为Entry把键定义成了弱引用类型，key在父类WeakReference里面，可以通过Entry.get()获取到这个key（下面是ThreadLocal内存泄漏的原因，觉得太难可以不看)
2. 为什么要把键定义成弱引用类型，防止内存泄漏，ThreadLocal如果定义成强引用类型则一直被Entry引用着ThreadLocal，Entry又存在于ThreadLocalMap，ThreadLocalMap又存在于Thread而一般业务场景使用线程池，则Thread要循环利用，所以导致ThreadLocal也无法回收，
3. 把键定义成了弱引用类型出现了什么问题，ThreadLocal因为是弱引用类型所以逃不过一次GC，但我们平常使用的时候会先创建ThreadLocal我们给它了一个强引用，所以这时不会回收，当我们去掉这个强引用时，它就直接被GC回收了，此时Entry的key为null，那我们则无法使用Entry的value，因为Entry是键值对，如果键都没有了，怎么通过键找到值呢
4. 如何解决Entry的key为null时value无法使用导致的内存泄漏问题，可以通过expungeStaleEntry回收key为null的Entry
5. 为什么不把值也设为弱引用，因为我们使用ThreadLocal时一定会给他一个强引用，如果这个强引用我们去掉，那么我们肯定是想回收ThreadLocal，而如果值也是弱引用时，且我们不想有其他引用指向该值，只想通过Entry把值取出来用，那样取出来的值可能是null，因为它已经被GC回收了

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

检索操作（查操作）

getEntry操作

1. 根据ThreadLocal的threadLocalHashCode属性计算索引，a & 5 永远不会大于 5，用这种方式方式索引溢出
2. 用计算的索引从Entry数组中取出Entry键值对出来
3. 判断取出的Entry是否合法，即不为空且Entry的key等于给定的key
4. 如果不合法则执行getEntryAfterMiss

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

getEntryAfterMiss操作

1. 这里的e是上面传过来的，只有两种情况，如果e为null，那说明ThreadLocalMap中没有该key对应的键值对
2. 如果e不为空，那说明上面的e.get() != key, e.get() 是Entry的key，为什么要这样取出来，因为Entry的键ThreadLocal是弱引用类型
3. 为什么用key.threadLocalHashCode算出来的索引对应的Entry不是我们想要的呢，因为Hash冲突，而ThreadLocalMap解决Hash冲突的办法是开放寻址法，就是从计算出的索引后面找，直到找到一个键值对Entry的key等于给定的键key
4. while循环里面就是解决哈希冲突的开放寻址法，先e.get()获取当前Entry的key，如果key等于给定的键key则返回该Entry键值对
5. 如果Entry的key等于null，说明该Entry已经内存泄漏了，无法通过key获取value了，需要调用expungeStaleEntry清除该Entry
6. 如果Entry的key不为null且又不等于给定key，那说明需要往后找值，nextIndex(i, len)就相当于i++，但是如果i++超出Entry数组索引，i会变为0
7. i++后此时Entry替换成后面一个Entry，一直循环直到找到要找的Entry，即满足Entry.get() == key

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)
             // 清除该Entry
             expungeStaleEntry(i);
         else
             // i自增取模
             i = nextIndex(i, len);
         e = tab[i];
     }
     return null;
 }

expungeStaleEntry操作

1. staleSlot是不新鲜的Entry的下标，直接操作table将Entry中指向value的引用置空，再将table指向该Entry的索引置空，帮助它们被GC收集
2. size是table中有效键值对个数，减一
3. 然后进行的操作是遍历Entry数组table，找Entry的key为null的Entry将其释放，如果遇到Entry的key不null则重新计算其索引，把它放到离计算索引最近的位置（这叫再Hash)
4. nextIndex(staleSlot, len)是将i自增取模

private int expungeStaleEntry(int staleSlot) {
    Entry[] tab = table;
    int len = tab.length;
    // 直接操作table
    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();
        // 找Entry的key为null的Entry将其释放
        if (k == null) {
            e.value = null;
            tab[i] = null;
            size--;
        } else {
        	// 再Hash
            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;
}

增加和修改操作（增改操作）

set操作

1. 和检索操作一样先计算索引，再找Entry，Entry不合法则往后面找，如果找到了说明原来有该key对应的Entry，只要进行修改操作，则将该Entry的值更新就行了
2. 遇到Entry的key为null会进行replaceStaleEntry操作，为什么不和检索操作一样用expungeStaleEntry清除内存泄漏的Entry呢，因为如果一个Entry已经无效了我们不如把它的key和value替换成我们要添加的键值对的key和value，这样还省掉了new Entry()的操作，如果真的替换成功直接返回
3. 如果在第一步即没遇到key为null的Entry，也找不到key等于给定key的Entry，则创建一个Entry放在用给定key计算的索引处，如果Hash冲突，就用开放寻址法解决，一直往后找个空位
4. 往Entry数组添加进了一个键值对，那么size肯定会增加，那它有可能超出阈值threshold，这时我们有两种解决办法，调用cleanSomeSlots尽量清除一个无效的Entry那我们就不用扩容了，如果什么都没清除，且size大于等于阈值threshold则只能执行rehash()进行扩容

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

replaceStaleEntry操作

1. 这里的操作是想找到一个无效的Entry，把它的key和value的值替换成我们给定的key和value，但在这之前要考虑，如果已经存在一个Entry的key和我们给定的key一样，那说明我们要执行的是修改操作，而不是添加操作，第二个for循环就是干这件事情的，找是否存在一个Entry的key与给定key一样
2. 第一个for循环是在往前找，找到最前面一个无效entry的索引，记为slotToExpunge，方便后面调用expungeStaleEntry清除无效的entry
3. prevIndex相当于i–，减到-1则将其设为len-1，即Entry数组最后一个索引
4. 第二个for循环后面就是如果没有找到一个Entry的key与给定key一样，则直接将一开始staleSlot下标这个无效Entry的key和value都替换成新的
5. 可以看到不管怎样，都会执行cleanSomeSlots和expungeStaleEntry两个清除操作的，从这里就可以找到ThreadLocalMap把清除内存泄漏的Entry的任务分散在每一个增删改查的过程中

 private void replaceStaleEntry(ThreadLocal<?> key, Object value,
                                       int staleSlot) {
    Entry[] tab = table;
    int len = tab.length;
    Entry e;
    int slotToExpunge = staleSlot;
    // 往前找无效的entry的索引
    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();
        // 找到一个Entry的key与给定key一样，执行修改操作
        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);
}

cleanSomeSlots操作

1. 都是清除操作 cleanSomeSlots和expungeStaleEntry有什么不同呢，expungeStaleEntry从第一个无效Entry的索引staleSlot往后找遇到Entry[i]为null就不往后找了，但其实null后面还有元素的
2. cleanSomeSlots不管那么多，它只往后面找log2(n)次，n是Entry数组的长度，就算遇到Entry[i]为null也无所谓，但是如果找到了一个Entry不为空但Entry的key为null的元素就使用expungeStaleEntry去收集无效Entry，而且cleanSomeSlots会重新刷新n的值，再往后面找log2(n)，一直死循环，直到找过log2(n)都没发现无效Entry

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);
        }
    // 控制查找次数为log2(n)，n>>>=1为n = n >>> 1,>>>是无符号右移
    } while ( (n >>>= 1) != 0);
    return removed;
}

rehash操作

1. set操作可能添加元素，会涉及到扩容，rehash操作就包括了扩容和再hash的意思
2. 先调用expungeStaleEntries删除表中所有过时的条目。
3. 如果Entry数组table中的有效键值对数size的大小超过阈值的四分之三，则进行resize()扩容操作

 private void rehash() {
    expungeStaleEntries();
    if (size >= threshold - threshold / 4)
        resize();
}

expungeStaleEntries操作

遍历整个entry数组table，找到一个无效entry则调用expungeStaleEntry回收无效entry

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

resize操作

1. 创建新的Entry数组newTab，它的长度是老数组的两倍，双倍扩容
2. 遍历老数组，将其中不为null的Entry的key通过 e.get()取出来（弱引用取出方式），如果key为null，则将其value设为空，帮助value被GC回收，否则即Entry有效
3. Entry有效时利用其key，也就是ThreadLocal中属性threadLocalHashCode重新计算其在新数组newTab的下标，把该Entry放入新数组，如果有hash冲突，使用开放寻址法解决
4. 设置新的阈值threshold，设置新的size，设置ThreadLocalMap中的table为新的newTab

private void resize() {
    Entry[] oldTab = table;
    int oldLen = oldTab.length;
    int newLen = oldLen * 2;
    // 创建新的Entry数组
    Entry[] newTab = new Entry[newLen];
    int count = 0;
    for (Entry e : oldTab) {
        if (e != null) {
            ThreadLocal<?> k = e.get();
            if (k == null) {
                e.value = null;
            } 
            else {
                int h = k.threadLocalHashCode & (newLen - 1);
                // 如果有hash冲突，使用开放寻址法解决
                while (newTab[h] != null)
                    h = nextIndex(h, newLen);
                newTab[h] = e;
                count++;
            }
        }
    }
    setThreshold(newLen);
    size = count;
    table = newTab;
}

删除操作

remove操作

根据key.threadLocalHashCode计算索引，一直往后找，找到则释放entry，顺便调用expungeStaleEntry从最开始计算的索引处回收无效的entry即可

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