J.U.C ThreadLocal(四) - 线程本地变量容器T

为什么要使用WeakReference

我们直到放入线程本地容器的值，变为线程局部变量。如果线程不停止，则永远无法回收。有人认为是脏Entry导致内存溢出的元凶，其实这个本质就是错误的，即使改为强引用同样不回回收。真正是元凶是线程一直没有关闭，如线程池。读过Tomcat源码中存在一个自定义线程池时刻处理连接请求，如果context重启时，监听器会发送一个事件给线程池，使其处理停止线程内work线程，其本质就是处理ThreadLocal导致内存溢出的问题。

脏Entry处理

插入处理

如果插入元素没有发生散列冲突，从插入下标位置开始向后探测擦除脏Entry(cleanSomeSlots)

如果插入元素发生散列冲突,用(replaceStaleEntry)处理

cleanSomeSlots

 /**
 * 从位置i开始向后扫描logN次，
 *   如果每发现一次脏Entry则，则调用expungeStaleEntry擦除脏Entry，
 *   其内部会继续向后探测脏Entry并擦除，把hash冲突节点填充到擦除的位置。直到找到一个空节点
 *   同时重新扫描次数为loglen
 *
 * 返回true则表示找到脏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);
        }
    } while ( (n >>>= 1) != 0);
    return removed;
}

/**
 * 1 擦除脏Entry，并从脏Entry位置开始向后查找脏Entry，发现则擦除直到一个空节点结束
 * 2 从当前staleSlot位置向后环形（nextIndex）继续搜索，发现冲突的节点填充到前面的擦除节点
 * 返回探测到为null节点
 */
private int expungeStaleEntry(int staleSlot) {
    Entry[] tab = table;
    int len = tab.length;

    /**  直接擦除指定索引位置Entry； **/
    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;
}

replaceStaleEntry

 /**
 * 1 从staleSlot向前找到第一个脏entry的位置slotToExpunge
 * 2 从staleSlot向后找到和传入key节点相同的节点，如果找到则替换该节点，直到遇到一个空节点结束
 * 3 如果步骤2没有找到key相同的节点，则表明staleSlot位置脏Entry节点就是需要替换的节点
 */
private void replaceStaleEntry(ThreadLocal<?> key, Object value,
                               int staleSlot) {
    Entry[] tab = table;
    int len = tab.length;
    Entry e;

    /** 从staleSlot向前找到第一个脏entry的位置slotToExpunge **/
    int slotToExpunge = staleSlot;
    for (int i = prevIndex(staleSlot, len);
         (e = tab[i]) != null;
         i = prevIndex(i, len))
        if (e.get() == null)
            slotToExpunge = i;

    /** 从staleSlot向后找和传入key相同的节点， **/
    for (int i = nextIndex(staleSlot, len);
         (e = tab[i]) != null;
         i = nextIndex(i, len)) {
        ThreadLocal<?> k = e.get();


        /** 从staleSlot向后找到和传入key节点相同的节点，如果找到则替换该节点 **/
        if (k == key) {
            e.value = value;

            tab[i] = tab[staleSlot];
            tab[staleSlot] = e;

            /** 如果向前未搜索到脏entry，则从slotToExpunge节点位置开始清理脏 **/
            if (slotToExpunge == staleSlot)
                slotToExpunge = i;
            cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
            return;
        }

        /**  **/
        if (k == null && slotToExpunge == staleSlot)
            slotToExpunge = i;
    }

    /** staleSlot位置脏Entry节点就是需要替换的节点 **/
    tab[staleSlot].value = null;
    tab[staleSlot] = new Entry(key, value);

    /** 如果向前未搜索到脏entry，则从slotToExpunge节点位置开始清理脏 **/
    if (slotToExpunge != staleSlot)
        cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
}