Netty源码分析2 - ThreadLocal 源码解析

netty新增了FastThreadLocal和FastThreadLocalThread等类来实现了一个FastThread框架，相较于java.lang.Thread和java.lang.ThreadLocal速度更快。
在看FastThread框架之前，先看一下java.lang.ThreadLocal的源码。

一、使用姿势
二、数据结构
三、源码分析
四、回收机制
总结

一、使用姿势

public class ThreadLocalTest {
    /**
     * 最佳实践一：使用private static
     * {@code ThreadLocal} instances are typically private static fields in classes
     * that wish to associate state with a thread (e.g., a user ID or Transaction ID)
     *
     * java8写法：
     * private static final ThreadLocal integerThreadLocal = ThreadLocal.withInitial(() -> 100);
     *
     * java8之前的写法：
     *      *     private static final ThreadLocal integerThreadLocal = new ThreadLocal() {
     *          @Override
     *          protected Integer initialValue() {
     *              return 100;
     *          }
     *      };
     * 
     */
    private static final ThreadLocal integerThreadLocal = new ThreadLocal() {
        /**
         * 最佳实践二：重写initialValue()
         */
        @Override
        protected Integer initialValue() {
            return 100;
        }
    };

    @Test
    public void testThreadLocal() {
        System.out.println(integerThreadLocal.get());
        /**
         * 最佳实践三：用完如果可以删除，则手动删除
         */
        integerThreadLocal.remove();
        System.out.println(integerThreadLocal.get());
    }
}

最佳实践

在类中定义ThreadLocal，用private static修饰；
根据源码分析，由于ThreadLocal对象本身会作为Entry的key去获取数据，所以最好也要用final去修饰。key通常都是不可变对象，否则当作为key的对象发生了变化之后，之前存储的数据将无法get，造成资源泄露；
使用匿名内部类实现initialValue()，在执行get()时，如果当前的Thread的ThreadLocalMap没有integerThreadLocal这个key的Entry（不管是第一次get还是remove之后的第一次get），则直接使用initialValue()进行初始化操作；
在使用完ThreadLocal后，及时手动remove()无用的ThreadLocal，防止资源泄露

二、数据结构

threadlocal.png

说明

每一个Thread类都有一个属性：ThreadLocal.ThreadLocalMap threadLocals = null
每一个ThreadLocalMap都有一个Entry[]数组
每一个Entry继承于WeakReference，Entry的key（ThreadLocal实例）作为WeakReference的referent，传入的value作为value

java引用：

https://www.cnblogs.com/absfree/p/5555687.html
http://puretech.iteye.com/blog/2008663

注意

从第三条说明点发现每一个ThreadLocal只能存储一个值，对于dubbo的RpcContext.LOCAL来讲，存储了一个RpcContext上下文信息；如果需要存储多个值，根据情况，将多个值合并为对象进行存储或者使用多个ThreadLocal实例进行存储

三、源码分析

3.1、ThreadLocal的创建

基础属性

    /**
     * 每一个ThreadLocal对象都有一个唯一的threadLocalHashCode。
     * ThreadLocal对象会作为ThreadLocalMap的Entry的key     
     */
    private final int threadLocalHashCode = nextHashCode();

    private static AtomicInteger nextHashCode = new AtomicInteger();

    /**
     * 魔数：与斐波那契数列和黄金分割点有关。用于散列均匀，减少hash冲突
     */
    private static final int HASH_INCREMENT = 0x61c88647;

    private static int nextHashCode() {
        return nextHashCode.getAndAdd(HASH_INCREMENT);
    }

说明

每一个ThreadLocal对象都有一个唯一的threadLocalHashCode，该值用于计算Entry元素存储的直接索引。
- 直接索引：元素根据threadLocalHashCode&(table.len-1)算出来的值
- 真实索引：元素可能由于hash冲突，使用线性探测法，放置在不是直接索引的位置
hash算法：每一个ThreadLocal的threadLocalHashCode都是前一个的threadLocalHashCode + 0x61c88647。这样的hash算法可以很大程度的避免hash冲突，散列很均匀。0x61c88647这个数是怎么算出来的，见：https://www.javaspecialists.eu/archive/Issue164.html

普通构造函数

    public ThreadLocal() {
    }

java8提供的构造函数

    public static  ThreadLocal withInitial(Supplier supplier) {
        return new SuppliedThreadLocal<>(supplier);
    }
    
    static final class SuppliedThreadLocal extends ThreadLocal {

        private final Supplier supplier;

        SuppliedThreadLocal(Supplier supplier) {
            this.supplier = Objects.requireNonNull(supplier);
        }

        @Override
        protected T initialValue() {
            return supplier.get();
        }
    }

java8提供了Supplier（提供者） FunctionalInterface。基于该接口可以方便的替代掉示例中的使用匿名内部类来重写initialValue()的方法。需要注意的是，supplier函数不可为null。

@FunctionalInterface public interface Supplier { /** * Gets a result. */ T get(); }

3.2 数据的初始化与设置

/** * 设置初始值 * 与set(T value)几乎相同，下边代码等价于 * * private T setInitialValue() { * T value = initialValue(); * set(value); * return value; * } * */ private T setInitialValue() { // 获取初始值（通常是调用使用方重写的initialValue()，否则使用{@link ThreadLocal#initialValue()返回null}） T value = initialValue(); // 获取当前线程 Thread t = Thread.currentThread(); // 获取当前线程的ThreadLocalMap对象 ThreadLocalMap map = getMap(t); // 如果当前线程的ThreadLocalMap对象不为null，则直接将{当前的ThreadLocal对象，value}设置到ThreadLocalMap对象中去 if (map != null) map.set(this, value); // 如果当前线程的ThreadLocalMap为null，则直接新建ThreadLocalMap对象，并将{当前的ThreadLocal对象，value}设置到ThreadLocalMap对象中去 else createMap(t, value); // 返回初始值 return value; } protected T initialValue() { return null; } /** * 设置值 */ public void set(T value) { // 获取当前线程 Thread t = Thread.currentThread(); // 获取当前线程的ThreadLocalMap对象 ThreadLocalMap map = getMap(t); // 如果当前线程的ThreadLocalMap对象不为null，则直接将{当前的ThreadLocal对象，value}设置到ThreadLocalMap对象中去 if (map != null) map.set(this, value); // 如果当前线程的ThreadLocalMap为null，则直接新建ThreadLocalMap对象，并将{当前的ThreadLocal对象，value}设置到ThreadLocalMap对象中去 else createMap(t, value); } /** * 获取当前线程t的ThreadLocalMap */ ThreadLocalMap getMap(Thread t) { return t.threadLocals; } /** * 创建ThreadLocalMap，并将 {当前的ThreadLocal对象，firstValue} 设置到ThreadLocalMap对象中去 * this：当前的ThreadLocal对象 */ void createMap(Thread t, T firstValue) { t.threadLocals = new ThreadLocalMap(this, firstValue); }

setInitialValue()流程：

首先调用initialValue()获取初始值（通常是调用使用方重写的initialValue()，否则返回null）

然后获取当前线程

然后获取当前线程的ThreadLocalMap对象属性

如果当前线程的ThreadLocalMap对象不为null，则直接将{当前的ThreadLocal对象，value}设置到ThreadLocalMap对象中去

如果当前线程的ThreadLocalMap为null，则直接新建ThreadLocalMap对象，并将{当前的ThreadLocal对象，value}设置到ThreadLocalMap对象中去

最后返回initialValue()获取到的初始值

setInitialValue()被使用的时机：ThreadLocal.get()。

关于ThreadLocalMap的创建和向ThreadLocalMap中设置参数的源码后续再说。

3.3 数据的获取

public T get() { // 获取当前线程 Thread t = Thread.currentThread(); // 获取当前线程的ThreadLocalMap属性 ThreadLocalMap map = getMap(t); if (map != null) { // 从ThreadLocalMap属性中获取key为当前的ThreadLocal的Entry ThreadLocalMap.Entry e = map.getEntry(this); if (e != null) { // 如果Entry不为null，直接获取entry的value，返回即可 @SuppressWarnings("unchecked") T result = (T) e.value; return result; } } // 如果当前线程的ThreadLocalMap为null或者key为当前的ThreadLocal的Entry为null return setInitialValue(); }

get()流程：

获取当前线程

获取当前线程的ThreadLocalMap属性

如果当前线程的ThreadLocalMap对象不为null，从ThreadLocalMap对象中获取key为当前的ThreadLocal的Entry

如果该Entry不为null，直接获取entry的value，返回即可

如果当前线程的ThreadLocalMap为null（还未createMap(Thread t, T firstValue)）或者key为当前的ThreadLocal的Entry为null（没有调用map.set(this, value)），则执行设置初始化值的方法。

关于根据ThreadLocal从ThreadLocalMap中获取Entry的源码后续再说。

3.4 数据的删除

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

remove()步骤：

获取当前的线程

获取当前线程的ThreadLocalMap

如果当前的ThreadLocalMap不为null，直接执行调用ThreadLocalMap的remove(ThreadLocal key)

关于根据ThreadLocal从ThreadLocalMap中remove Entry的源码后续再说。

可以看到具体的操作全部委托到了ThreadLocalMap中来执行。

3.5 ThreadLocalMap的创建

基础属性

/** * The initial capacity -- MUST be a power of two. */ private static final int INITIAL_CAPACITY = 16; /** * The table, resized as necessary. * table.length MUST always be a power of two. */ private Entry[] table; /** * The number of entries in the table. */ private int size = 0; /** * threshold == table大小的2/3， * 1、当size >= threshold，遍历table并删除所有key为null的元素（rehash()）， * 2、如果删除后size >= threshold*3/4 == 数组长度*1/2 时，需要对table进行扩容 */ private int threshold; // Default to 0 private void setThreshold(int len) { threshold = len * 2 / 3; }

静态内部类Entry

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

其中value就是set的value，而k是当前的ThreadLocal对象，作为WeakReference的referent属性。

构造器

ThreadLocalMap(ThreadLocal firstKey, Object firstValue) { // 创建数组实例，默认长度16 table = new Entry[INITIAL_CAPACITY]; // 求余计算数组索引i int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1); // 第一次插入，没有hash冲突，直接放置 table[i] = new Entry(firstKey, firstValue); // 数组实际元素长度 + 1 size = 1; // 设置扩容的阈值为 16*2/3 = 10，当有10个元素时，发生扩容 setThreshold(INITIAL_CAPACITY); }

步骤：

创建数组实例，默认长度16

计算firstKey的直接索引，当len=2的n次方时，x&(len-1) <=> x%len，所以这里相当于直接求余，只是&运算效率更高

第一次插入，没有hash冲突，直接创建Entry并放置就ok了

然后数组中元素个数size+1

设置rehash()的阈值

索引操作

/** * i：数组索引 * len：数组长度 * 如果 i+1<数组长度，则返回i+1, 如果 i+1>=数组长度，则直接取0（即开头table[0]）， * 在实际使用中，实际上就是不断向后的循环取，到了末尾，再回到table[0]，再向后循环取 */ private static int nextIndex(int i, int len) { return ((i + 1 < len) ? i + 1 : 0); } /** * 如果 i-1>=0，则返回i-1, 如果 i<1，则直接取数组长度-1（即末尾table[len-1]）， * 在实际使用中，实际上就是不断向前的循环取，到了开头，再回到table[len-1]，再向前循环取 */ private static int prevIndex(int i, int len) { return ((i - 1 >= 0) ? i - 1 : len - 1); }

从上述的逻辑可知，我们可以将table[]看做是一个循环数组。

3.6 向ThreadLocalMap中设置Entry

/** * 设置 {key, value} 到当前线程的ThreadLocalMap中 */ private void set(ThreadLocal key, Object value) { // 成员变量局部化，提高性能 Entry[] tab = table; // 获取数组容量 int len = tab.length; // 获取当前的threadlocal位于数组的下标，当len=2的n次方时， // key.threadLocalHashCode & (len - 1) <=> key.threadLocalHashCode % len int i = key.threadLocalHashCode & (len - 1); /** * 先获取tab[i]，判断如果不为null，则进行循环体内逻辑； * 若没有return，则进行二次循环，tab[i+1]，判断如果不为null，则进行循环体内逻辑； * 当 i + 1 >= len 时，tab[0]回到头再进行循环。 * * 这就是解决hash冲突的另一种方式：线性探测法。如果当前槽没有元素，直接插入元素；如果当前槽有元素，则向后寻找第一个为null的槽，放置该元素。 * 在这里，还添加了hash冲突时替换原有元素或者替换无效元素的逻辑。 */ for (Entry e = tab[i]; e != null; e = tab[i = nextIndex(i, len)]) { // 获取当前的Entry的key，使用e.get()，是因为当前的key是一个WeakReference，使用get()获取key ThreadLocal k = e.get(); // 如果当前的key就是刚刚查询出来的Entry的key(即修改的是同一个Entry)，则直接替换值 if (k == key) { e.value = value; return; } // 如果刚刚查询出来的Entry的key是null，则表明该Entry的key（ThreadLocal）已经被回收了 // 使用replaceStaleEntry替换掉已经无效的Entry if (k == null) { replaceStaleEntry(key, value, i); return; } } // 通过上述for循环解决了hash冲突之后，创建新的Entry，放置到当前的table[i]节点上 tab[i] = new Entry(key, value); // table的size+1 int sz = ++size; // 回收部分无效的Entry，如果成功，则当前的数组中的元素个数将小于阈值，则肯定不需要扩容， // 否则判断当前的数组中的元素个数是否达到了扩容阈值 if (!cleanSomeSlots(i, sz) && sz >= threshold) rehash(); }

说明：

首先将table[]成员变量局部化（在后续的操作中如果会对table成员变量进行多次操作，局部化会提高性能）

获取数组长度，计算直接索引

然后进行hash冲突检测与处理（线性探测法）

获取直接索引位置的Entry，如果不为null，表示发生了hash冲突，则先获取Entry中的key，如果该key与当前的ThreadLocal是同一个对象，则直接替换value，返回；

如果Entry中的key==null，表示当前的Entry已经是一个无效的Entry了，执行replaceStaleEntry方法进行处理（如果从该Entry后的第一个元素开始在一个连续的Entry子数组内找到一个key与当前ThreadLocal相等的元素，则替换值，然后互换该Entry和当前的key==null的Entry位置；如果没找到，则将当前的key==null的Entry设置为新的将设置的Entry）返回；

如果发生了hash冲突，但是直接索引位置上的Entry即不是当前的ThreadLocal的Entry，也不是一个无效的Entry，则需要向后循环遍历下一个Entry元素，再进行上述逻辑的处理。直到找到一个Entry为null的位置或者Entry失效的位置或者Entry就是当前的ThreadLocal的Entry的位置。

假设没有发生hash冲突或者经过上述的for循环找到了一个Entry为null的位置的时候，在该位置创建设置新添加的Entry，数组元素+1；

尝试回收部分无效的Entry，如果成功，则当前的数组中的元素个数将小于阈值，则肯定不需要rehash()；如果失败，且数组元素个数 > threshold，执行rehash() -- 即执行部分资源清理与可能的扩容操作。

replaceStaleEntry(ThreadLocal key, Object value, int staleSlot)

/** * 对一段连续的Entry子数组进行操作 * Replace a stale entry encountered during a set operation * with an entry for the specified key. */ private void replaceStaleEntry(ThreadLocal key, Object value, int staleSlot) { // 获取当前的table及其容量 Entry[] tab = table; int len = tab.length; Entry e; // 设置需要被回收的槽索引（无效的Entry索引） int slotToExpunge = staleSlot; /** * 向前遍历，直到找到第一个为null的槽 * 在遍历的过程中，如果找到了无效的Entry，则将slotToExpunge设置为当前的被回收的无效索引 */ for (int i = prevIndex(staleSlot, len); (e = tab[i]) != null; i = prevIndex(i, len)) if (e.get() == null) slotToExpunge = i; /** * 向后遍历，直到找到第一个为null的槽或者找到与当前Entry key相等的槽 */ for (int i = nextIndex(staleSlot, len); (e = tab[i]) != null; i = nextIndex(i, len)) { ThreadLocal k = e.get(); // The newly stale slot, or any other stale slot // encountered above it, can then be sent to expungeStaleEntry // to remove or rehash all of the other entries in run. // 如果key相等，直接替换 if (k == key) { // 替换值 e.value = value; /** * 互换 tab[i] 和 tab[staleSlot]，将无效的tab[staleSlot]中的Entry后移； * 将正确的 tab[i]中的Entry前移，方便下一次的查找（可以根据直接槽索引查找到了） */ tab[i] = tab[staleSlot]; tab[staleSlot] = e; // 如果待回收的槽索引就是当前的无效索引，则设置待回收的槽索引为i if (slotToExpunge == staleSlot) slotToExpunge = i; cleanSomeSlots(expungeStaleEntry(slotToExpunge), len); return; } // 如果 "k==null && 待回收的槽索引就是当前的无效索引"，则设置待回收的槽索引为i if (k == null && slotToExpunge == staleSlot) slotToExpunge = i; } // 置空原本的entry的value，将当前的Entry添加到这个槽上，原本的Entry等待GC tab[staleSlot].value = null; tab[staleSlot] = new Entry(key, value); // If there are any other stale entries in run, expunge them if (slotToExpunge != staleSlot) cleanSomeSlots(expungeStaleEntry(slotToExpunge), len); }

步骤：

首先从当前索引staleSlot的前一个元素开始向前遍历一个连续的Entry子数组，一直找到该连续子数组最靠前的那个无效索引，设置为slotToExpunge

然后从staleSlot的 后一个元素开始 向后遍历一个连续的Entry子数组

如果找到的Entry的key是当前的ThreadLocal，则直接替换value，之后将找到的Entry放置到table[staleSlot]处，也就是Entry本身的直接索引处，而Entry本身的真实索引的位置放置为原来的table[staleSlot]；然后进行一次连续段的回收，之后进行一次log次数级别的回收，最后返回

如果经过循环，没有找到key与ThreadLocal相等的Entry，则直接将要set的Entry放置到table[staleSlot]处，最后根据需要进行一次连续段的回收，之后在进行一次log次数级别的回收

关于回收与扩容相关的操作，后续分析。

3.7 从ThreadLocalMap中获取Entry

private Entry getEntry(ThreadLocal key) { // 计算所查找的Entry在table[]中的索引 int i = key.threadLocalHashCode & (table.length - 1); Entry e = table[i]; // 如果快速查找到的Entry!=null并且key也相等，则直接返回(也就是说在直接的hash槽找到了Entry) 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; /** * 循环遍历，直到找到下一个不为null的Entry */ while (e != null) { ThreadLocal k = e.get(); // 如果key相等，表示找到了，直接返回 if (k == key) return e; // 如果key==null，则尝试回收或者整理"i到i之后的第一个Entry为null的索引（即返回值）之间"的Entry数据 if (k == null) expungeStaleEntry(i); // 继续向后遍历 else i = nextIndex(i, len); e = tab[i]; } // 如果没找到，返回null return null; }

步骤：

计算当前的ThreadLocal的直接索引，获取直接索引位置的Entry

如果该位置的Entry不为null且Entry的key与当前的ThreadLocal是同一个元素，则直接返回该Entry

如果该位置的Entry为null，直接返回null（看getEntryAfterMiss逻辑）

如果该位置的Entry不为null，但是Entry的key与当前的ThreadLocal不是同一个元素，则表明发生了hash冲突。此时，会不断的向后循环寻找，直到找到了要查找的Entry或者遍历到的Entry为null，如果找到了，返回Entry，如果没找到，返回null。

注意：

在没有根据直接索引找到Entry后的while循环中，如果检测到无效的Entry时，会使用expungeStaleEntry方法尝试回收或者整理"i到i之后的一段连续的不为null的索引（即返回值）之间"的Entry数据。

对于get来讲，线性探测法是以Entry!=null为循环查找结束条件的，所以要注意remove时的操作。

3.8 从ThreadLocalMap中删除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) { // key - ThreadLocal置为null e.clear(); // 尝试回收或者整理"i到i之后的一段连续的不为null的索引（即返回值）之间"的Entry数据 expungeStaleEntry(i); return; } } }

步骤：

计算key的直接索引，从直接索引的Entry开始，依旧在一段连续的不为null的Entry进行循环，如果找到的Entry的key与当前的key相同，则进行删除操作：

首先将Entry的key置空（e.clear()）

尝试回收或者整理"i到i之后的一段连续的不为null的索引（即返回值）之间"的Entry数据

注意：

这里的expungeStaleEntry中的整理逻辑非常重要，直接影响get查询的查询链是否会断掉的问题。

3.9 rehash()与resize()

private void rehash() { // 回收table中所有无效的Entry，如果可以有效减小size到不满足下边的扩容条件，则下边的resize()不需要执行 expungeStaleEntries(); // 实际上扩容是发生在size>=threshold*3/4==length*(2/3)*(3/4)==lenth*1/2 if (size >= threshold - threshold / 4) resize(); } /** * 扩容两倍数组，之后rehash */ private void resize() { // 获取旧数组及其长度 Entry[] oldTab = table; int oldLen = oldTab.length; // 新数组扩容2倍 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(); // 无效的Entry 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; }

rehash()仅用在ThreadLocalMap#set(ThreadLocal key, Object value)的末尾部分。

rehash()步骤：

首先进行一次全表回收无效的Entry操作，如果可以有效减小数组中的元素个数size到数组长度的一半以下，则不需要进行扩容，如果达到一半及以上，则进行扩容操作。

resize()步骤：

创建新的Entry[]是旧的长度的两倍；之后遍历旧数组，之后根据新的数组的长度重新计算每个有效Entry的直接索引，根据线性探测法重新填充数组。

最后设置新的Entry[]的阈值threshold、数组元素个数size，将新数组赋值给全局变量table

四、回收机制

ThreadLocal 回收机制就是如下的四个函数以及WeakReference>

1、expungeStaleEntry(int staleSlot) 从staleSlot开始的连续Entry子数组中的无效Entry的清理和整理： 2、expungeStaleEntries() 清理整个table中的无效Entry 3、cleanSomeSlots(int i, int n) 进行log2(n)次循环（如果正好遍历到无效的Entry，则n=table.length，调用expungeStaleEntry进行连续段的清理和整理）；是一种介于完全不扫描和完全扫描（expungeStaleEntries）之间的一种扫描方式 4、replaceStaleEntry(ThreadLocal key, Object value, int staleSlot) 该函数已在set部分分析：从table[staleSlot]后的第一个元素开始在一个连续的Entry子数组内如果找到一个key与当前ThreadLocal相等的Entry，则替换值，然后互换该Entry和table[staleSlot]（①），返回；如果没找到，则将table[staleSlot]直接设置为新的将设置的Entry（②） ①②处都会对该Entry所在的连续段，从连续段的第一个无效Entry（可能在当前的Entry之前）开始或者从该Entry的后一个元素开始（表示该Entry之前的元素全部有效）进行一次连续段的回收和整理，之后在进行一次log级别的回收；

4.1 expungeStaleEntry(int staleSlot)

/** * 尝试回收或者整理"staleSlot到staleSlot之后的第一个Entry为null的索引（即返回值）之间"的Entry数据 * * @return the index of the next null slot after staleSlot * (all between staleSlot and this slot will have been checked * for expunging). */ private int expungeStaleEntry(int staleSlot) { Entry[] tab = table; int len = tab.length; // 回收table[staleSlot]处的值，value置为null，整体置为null tab[staleSlot].value = null; tab[staleSlot] = null; // size-1 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(); // 如果当前的table[i] Entry无用，则直接回收 if (k == null) { e.value = null; tab[i] = null; size--; } else { /** * 问题： * 假设ThreadLocalMap的table长度为4的，其中table[1]、table[2]已经有值，而且key都不为null， * 这时候set一个threadlocal1，算出来的索引为1，根据线性探测法，最后会设置到table[3]； * 然后，table[2]被remove，此时table[2]==null; * 然后，get threadlocal1，此时算出索引还是1, 从table[1]向后查找，结果table[2]==null，则查找链就断了，结果返回null， * 而没有办法查找到真正的table[3]，这种情况threadlocal是怎么处理的呢？ * * 答案就是下边的代码：会对remove元素的后边的元素循环遍历，直到遍历到非null为止。对每个元素做如下逻辑： * 如果当前元素的k==null,则回收，如果不是无效元素，则计算其真实的直接索引，例如重新计算table[3]的索引，此处为1，与当前遍历的索引3不同， * 所以将table[3]先置空，然后从table[1]开始向后寻找第一个为null的位置，重新放置table[3]的元素，此处就是table[2]=table[3] * * 简言之：remove一个Entry之后，会整理remove的Entry元素之后的一块儿连续的（中间没有null的entry）元素子数组，全部使用线性探测法重新计算， * 这样remove掉的那一块儿就会被后续的Entry重新填充，查询链就不会断 */ // 计算真实的直接索引位置，因为可能k是因为hash冲突循环后移的 int h = k.threadLocalHashCode & (len - 1); // 如果h和i，不相等，表示确实k是循环后移了的 if (h != i) { // 首先将之前的Entry置为null tab[i] = null; // 一直向后循环找到第一个为null的索引，之后table[h] = e（将当前的Entry放置到table[h]新的hash位置上） while (tab[h] != null) h = nextIndex(h, len); tab[h] = e; } } } return i; }

步骤：

将table[staleSlot]的value和Entry都置为null，元素个数size - 1

遍历staleSlot之后的一段连续的Entry，如果Entry的key==null，将该Entry的value和Entry本身置空，如果key是有效的，将要进行 整理操作

计算直接索引的位置，如果当前的Entry的真实索引与直接索引不相等，则表示该Entry之前是因为hash冲突被冲到后边的slot里的，此处会重新从直接索引位置开始向后找到第一个不为null的的位置，将当前的Entry元素放置到这里，这样会保证原本连续的Entry子数组，在从中删除一个Entry后，子数组中剩下的元素还可以组成一个连续的Entry数组，这保证了get操作的查询链不会断。

注意：

remove一个元素后，会调用这里的 整理操作 进行连续Entry子数组的整理，不会使查询链断掉。要仔细的看注释中的那个例子。

整理的过程相当于一次从staleSlot开始的连续段 内存碎片整理，将无效的Entry删除，有效的Entry按照原本的顺序聚集。

4.2 expungeStaleEntries()

/** * 回收table中所有的无效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); } }

遍历table中所有的元素，发现无效的Entry后，就调用expungeStaleEntry(int staleSlot)进行连续子数组的资源清理与整理。该方法影响较大，仅仅用在rehash()中。

4.3 cleanSomeSlots(int i, int n)

/** * 对数级别的扫描，介于 "不扫描（fast but retains garbage）" 和 "完全扫描（find all garbage but would cause some insertions to take O(n) time）" 之间 * * @param i a position known NOT to hold a stale entry. The * scan starts at the element after i. * @param n scan control: {@code log2(n)} cells are scanned, * unless a stale entry is found, in which case * {@code log2(table.length)-1} additional cells are scanned. * When called from insertions, this parameter is the number * of elements, but when from replaceStaleEntry, it is the * table length. (Note: all this could be changed to be either * more or less aggressive by weighting n instead of just * using straight log n. But this version is simple, fast, and * seems to work well.) * @return true if any stale entries have been removed. */ private boolean cleanSomeSlots(int i, int n) { boolean removed = false; Entry[] tab = table; int len = tab.length; do { // 向后循环获取下一个索引，如果已经到了末尾，则返回table[0] i = nextIndex(i, len); Entry e = tab[i]; // 如果此Entry已经无效了，key-ThreadLocal已经被回收掉了，无法再通过该key获取Entry，如果不回收此Entry，则会造成内存泄露 if (e != null && e.get() == null) { n = len; removed = true; // 尝试回收或者rehash"i到i之后的第一个Entry为null的索引（即返回值）之间"的Entry数据 i = expungeStaleEntry(i); } } while ((n >>>= 1) != 0); // n / 2，假设n=16，当然set的时候n=size，则log2(16)=4，也就是说需要循环4次（也可以直接理解为16/2/2/2/2=1，第5次1/2==0则不再进行循环） return removed; }

该方法只扫描一部分Entry，进行log2(n)次循环，如果恰好扫描到无效的Entry，则n=table.length，即进行log2(table.length)次循环。每个循环的步骤：

获取下一个索引位置i及该位置上的Entry

如果该Entry==null或者Entry依然有效，则进行下一次循环；

如果该Entry!=null且无效，则先将n设置为长度（在set方法中n本来是）调用expungeStaleEntry(i)回收或者整理 i之后的一段连续的Entry，之后再进行一下轮的回收和整理操作。

4.4 弱引用WeakReference

由于Entry继承了弱引用，他的key是referent，当发生gc时，如果该key已经不可达了，则直接回收（key==null），之后在如下操作时删除key==null的Entry。

get时调用expungeStaleEntry

set时调用replaceStaleEntry或者cleanSomeSlots或者expungeStaleEntries

remove时调用expungeStaleEntry

五、总结

5.1 set整个流程

首先将table[]成员变量局部化（在后续的操作中如果会对table成员变量进行多次操作，局部化会提高性能）

获取数组长度，计算直接索引

然后进行hash冲突检测与处理（线性探测法）

获取直接索引位置上的Entry，如果不为null，表示发生了hash冲突，则先获取Entry中的key，如果该key与当前的ThreadLocal是同一个对象，则直接替换value，返回；

如果Entry中的key==null，表示当前的Entry已经是一个无效的Entry了，执行replaceStaleEntry方法进行处理（replaceStaleEntry：如果从该Entry后的第一个元素开始在一个连续的Entry子数组内找到一个key与当前ThreadLocal相等的元素，则替换值，然后互换该Entry和当前的key==null的Entry位置；如果没找到，则将当前的key==null的Entry设置为新的将设置的Entry）返回；

如果发生了hash冲突，但是直接索引位置上的Entry即不是当前的ThreadLocal的Entry，也不是一个无效的Entry，则需要向后循环遍历下一个Entry元素，再进行上述逻辑的处理。直到找到一个Entry为null的位置或者Entry失效的位置或者Entry就是当前的ThreadLocal的Entry的位置。

假设没有发生hash冲突或者经过上述的for循环找到了一个Entry为null的位置的时候，在该位置创建设置新添加的Entry，数组元素+1；

尝试log级别的回收部分无效的Entry，如果成功，则当前的数组中的元素个数将小于阈值，则肯定不需要rehash()；如果失败，且数组元素个数 >= threshold，执行rehash()

首先对整个table回收无效的Entry操作，如果可以有效减小数组中的元素个数size到数组长度的一半以下，则不需要进行扩容，如果size达到length的一半及以上，则进行扩容操作

扩容：创建新的Entry[]是旧的长度的两倍；之后遍历旧数组，根据新的数组的长度重新计算每个有效Entry的直接索引，根据线性探测法重新填充数组。
最后设置rehash()阈值、数组元素个数size，将新数组赋值给全局变量table。

5.2 get整个流程

获取当前线程

获取当前线程的ThreadLocalMap属性

如果当前线程的ThreadLocalMap对象不为null，从ThreadLocalMap对象中获取key为当前的ThreadLocal的Entry

计算当前的ThreadLocal的直接索引，获取直接索引位置的Entry

如果该位置的Entry不为null且Entry的key与当前的ThreadLocal是同一个元素，则直接返回该Entry

如果该位置的Entry为null，直接返回null（看getEntryAfterMiss逻辑）

如果该位置的Entry不为null，但是Entry的key与当前的ThreadLocal不是同一个元素，则表明发生了hash冲突。此时，会不断的向后循环寻找，直到找到了要查找的Entry或者遍历到的Entry为null，如果找到了，返回Entry，如果没找到，返回null。

如果该Entry不为null，直接获取entry的value，返回即可

如果当前线程的ThreadLocalMap为null（还未createMap(Thread t, T firstValue)）或者key为当前的ThreadLocal的Entry为null（没有调用map.set(this, value)），则执行设置初始化值的方法。

5.3 各类回收的时机

set或者setInitialValue

如果从直接索引开始向后遍历的一段连续Entry段内发生hash冲突且冲突的Entry已经是无效的，此时会执行replaceStaleEntry，会执行回收和整理操作

如果没有发生hash冲突或者发生了hash冲突但是在从直接索引开始的一段连续Entry段内没有找到与设置的key相等的Entry或者无效的Entry，如果直接索引所在的整个连续Entry段如果有无效Entry，则在set的尾部都会执行一次log级别的回收操作，如果回收不理想，需要进行rehash()

rehash()会进行一次全table的回收

get

在通过直接索引没有get到数据的时候，会循环遍历一段连续的Entry，如果遍历到的Entry是无效的，则进行一次连续Entry子数组的回收和整理

remove

当找到需要被删除的Entry时，进行一次连续Entry子数组的回收和整理

gc时

由于Entry继承了弱引用，他的key是referent，当发生gc时，如果该key已经无引用指向了，则直接回收（key==null了），之后再根据上述1，2，3的操作删除key==null的Entry。（这也是为什么ThreadLocal没有为Entry绑定ReferenceQueue的原因，因为Entry的删除已经可以发生在1，2，3中了；但是WeakHashMap不一样，WeakHashMap的Entry继承于WeakReference，其key是referent，当发生gc时，如果key不可达了，则回收key，之后将key对应的Entry放入queue，在后续对WeakHashMap的操作 - getTable()/size()/resize(int newCapacity)的时候进行Entry的回收）

5.4 ThreadLocal与线程池

线程池中的线程由于会被复用，所以线程池中的每一条线程在执行task结束后，要清理掉其ThreadLocalMap及其中的各个Entry，否则，当这条线程在下一次被复用的时候，其ThreadLocalMap信息还存储着上一次被使用的时的信息；另外，假设这条线程不再被使用，但是这个线程有可能不会被销毁（与线程池的类型和配置相关），那么其上的ThreadLocal将发生了资源泄露。所以netty的io线程池使用FastThreadLocalRunnable wrap了Runnable任务，当任务执行结束后，会做InternalThreadLocalMap和FastThreadLocal的清理操作。

Netty源码分析2 - ThreadLocal 源码解析

一、使用姿势

最佳实践

二、数据结构

说明

注意

三、源码分析

3.1、ThreadLocal的创建

基础属性

普通构造函数

java8提供的构造函数

3.2 数据的初始化与设置

3.3 数据的获取

3.4 数据的删除

3.5 ThreadLocalMap的创建

基础属性

静态内部类Entry

构造器

索引操作

3.6 向ThreadLocalMap中设置Entry

replaceStaleEntry(ThreadLocal key, Object value, int staleSlot)

3.7 从ThreadLocalMap中获取Entry

3.8 从ThreadLocalMap中删除Entry

3.9 rehash()与resize()

四、回收机制

4.1 expungeStaleEntry(int staleSlot)

4.2 expungeStaleEntries()

4.3 cleanSomeSlots(int i, int n)

4.4 弱引用WeakReference

五、总结

5.1 set整个流程

5.2 get整个流程

5.3 各类回收的时机

5.4 ThreadLocal与线程池

你可能感兴趣的:(Netty源码分析2 - ThreadLocal 源码解析)