threadlocal

1、ThreadLocal内存泄漏原因

由于Entry中value是强引用，key为弱引用；当GC回收ThreadLocal后，由于value是强引用，无法被回收，所以造成了内存泄漏。
  因此，ThreadLocal内存泄漏的根源是：由于ThreadLocalMap的生命周期跟Thread一样长，如果没有手动删除对应的key就会导致内存泄漏，而并不是因为弱引用。

2、ThreadLocal.set（）方法源码

public void set(T value) {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
}

void createMap(Thread t, T firstValue) {
    t.threadLocals = new ThreadLocalMap(this, firstValue);
}

步骤：
1、获取Thread类中的threadlocals；
2、尝试根据threadlocals获取ThreadlocalMap
2.1 如果不存在则创建新的ThreadLocalMap，并往里set数据；
2.2 如果存在，则直接往ThreadLocalMap里set数据

3、ThreadLocal.get（）方法源码

步骤：
1、获取Thread类中的threadlocals；
2、尝试根据threadlocals获取ThreadlocalMap
2.1 如果存在，则根据threadlocals获取ThreadLocalMap.Entry，然后Entry.value则为结果
2.2 如果不存在，则通过setInitialValue()方法调用ThreadLocal.set（）方法，set一个key为threadlocals，value为null的Entry

    public T get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        return setInitialValue();
    }
    
    private T setInitialValue() {
        T value = initialValue();
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            map.set(this, value);
        } else {
            createMap(t, value);
        }
        if (this instanceof TerminatingThreadLocal) {
            TerminatingThreadLocal.register((TerminatingThreadLocal<?>) this);
        }
        return value;
    }

4、ThreadLocalMap.set（）方法源码

步骤：（详细代码见javaguide，这里只复述整个流程方便面试）
1、遍历当前key值对应的桶中Entry数据为空，这说明散列数组这里没有数据冲突，跳出for循环，直接set数据到对应的桶中
2、如果key值对应的桶中Entry数据不为空
2.1 如果k = key，说明当前set操作是一个替换操作，做替换逻辑，直接返回
2.2 如果key = null，说明当前桶位置的Entry是过期数据，执行replaceStaleEntry()方法，然后返回
2.2.1 首先从当前位置staleSlot向前循环查找是否还有其他key为null的数据，如果有的话，更新slotToExpunge下标位置（初始值slotToExpunge=staleSlot），结束条件为遇到Entry为null的数据
2.2.2 然后从当前位置staleSlot向后循环查找，结束条件为遇到Entry为null的数据
2.2.2.1 如果循环中的当前下标为i的Entry，key与当前线程的threadlocal相同，则将当前Entry的value设置为期望的value，并与下标位置为staleSlot的Entry进行交换。如果此时的staleSlot等于slotToExpunge，则将当前下标i赋予slotToExpunge（这一步是判断往前和往后循环过程中，是否遇到key为null的Entry）。最后调用数据清理方法【cleanSomeSlots(expungeStaleEntry(slotToExpunge), len)】，进行启发式过期数据清理，并返回。
2.2.2.2 如果循环中的当前下标为i的Entry的key为null且slotToExpunge == staleSlot，则更新slotToExpunge= i
2.2.3 执行到这一步，表明2.2.2中并没有发现与当前线程的threadlocal相同key的Entry，并且遇到Entry为null的数据，则此时直接将期望的新数据添加到table[staleSlot] 对应的下标位置上。最后判断slotToExpunge是否等于staleSlot，即如果不等于，表明还有其他key为null的数据，调用数据清理方法【cleanSomeSlots(expungeStaleEntry(slotToExpunge), len)】，进行启发式过期数据清理，并返回。
3、for循环执行完毕，继续往下执行说明向后迭代的过程中遇到了entry为null的情况
3.1 在Entry为null的桶中创建一个新的Entry对象
3.2 执行++size操作
4、调用cleanSomeSlots()做一次启发式清理工作，清理散列数组中Entry的key过期的数据
4.1 如果清理工作完成后，未清理到任何数据，且size超过了阈值(数组长度的 2/3)，进行rehash()操作
4.2 rehash()中会先进行一轮探测式清理，清理过期key，清理完成后如果size >= threshold - threshold / 4，就会执行真正的扩容逻辑(扩容逻辑往后看)

5、ThreadLocalMap过期 key 的探测式清理流程

步骤：
1、首先清空当前位置的数据，即将当前位置的Entry设置为null,size减一
2、以后一个下标位置开始进行循环，结束条件为Entry为null
2.1 如果遍历到key为null的数据，则同样将Entry设置为null，size减一
2.2 如果遍历到key不是为null的数据，则重新计算当前key的下标位置是不是当前槽位下标位置，如果不是，那么说明产生了hash冲突，此时以新计算出来正确的槽位位置往后迭代，找到最近一个可以存放entry的位置。
3、最后返回循环结束条件Entry为null的下标位置i。

6、ThreadLocalMap过期 key 的启发式清理流程

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

步骤：
1、传递进来两个参数，一个是下标i，一个是数组实际存在桶的长度n。执行循环，循环结束条件是n等于0。
1.1 以下标i + 1开始，判断当前桶Entry是否为null以及key是否为null，如果满足条件，则将数组长度赋予n， 并以当前位置执行探测式清理算法并将返回值赋予i。n缩小为一半，继续循环
2、根据是否有key为null的数据，返回true或false

7、ThreadLocalMap扩容机制

在ThreadLocalMap.set()方法的最后，如果执行完启发式清理工作后，未清理到任何数据，且当前散列数组中Entry的数量已经达到了列表的扩容阈值(len*2/3)，就开始执行rehash()方法：

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

步骤：
首先会进行探测式清理工作，从table的起始位置往后清理，一直循环到终止位置。清理完成之后，table中可能有一些key为null的Entry数据被清理掉，所以此时通过判断size >= threshold * 3/4 来决定是否扩容。

注意：
rehash()的阈值是size >= threshold，resize（）的阈值是size >= threshold * 3/4

8、ThreadLocalMap.get()源码

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

步骤：
1、通过所要查询的key计算下标位置，如果这个下标位置的key与要查询的key相等，则直接返回
2、如果不相等，则以当前位置往后循环查找，结束条件为Entry为null
2.1 如果找到key相等的数据，则直接返回
2.2 如果查询到key为null的数据，则以当前位置进行探测式清理算法，然后继续循环查找
2,3 如果上述两个条件都不满足，则下标加1，继续循环查找
3、执行到这步表示循环结束，则返回null。