ThreadLocal源码解读：内存泄露问题分析

/**
 * Expunge a stale entry by rehashing any possibly colliding entries
 * lying between staleSlot and the next null slot.  This also expunges
 * any other stale entries encountered before the trailing null.  See
 * Knuth, Section 6.4
 *
 * @param staleSlot index of slot known to have null key
 * @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) {
    // 入参 staleSlot: 待清理位置下标
    
    // 获取 ThreadLocalMap 中的 Entry 数组。
    ThreadLocal.ThreadLocalMap.Entry[] tab = table;
    // len 为当前 Entry 数组容量。
    int len = tab.length;

    // expunge entry at staleSlot
    // 清除当前 staleSlot 位置的过时 Entry。
    tab[staleSlot].value = null;
    tab[staleSlot] = null;
    // 元素数量减一。
    size--;

    // Rehash until we encounter null
    // 因为 ThreadLocalMap 解决哈希冲突采用的是线性探测法，如将当前下标位置赋值为 null ，但不对后续 Entry
    // 元素进行 rehash 操作，就可能导致存在哈希冲突的后置元素无法被探测到。所以将当前元素清理后需要
    // 对后续元素进行 rehash 操作，直到遇到下一个为 null 的元素。
    ThreadLocal.ThreadLocalMap.Entry e;
    int i;
    // nextIndex 用于向后递增索引 ((i + 1 < len) ? i + 1 : 0)
    for (i = nextIndex(staleSlot, len);
         (e = tab[i]) != null;
         i = nextIndex(i, len)) {
        ThreadLocal<?> k = e.get();
        if (k == null) {
            // 此时 Entry 不为 null，key 为 null，Entry 为过时 Entry 需清理掉。
            e.value = null;
            tab[i] = null;
            size--;
        } else {
            // 此时为有效 Entry，需要进行 rehash 操作重新定位。
            int h = k.threadLocalHashCode & (len - 1);
            if (h != i) {
                // 进入到这个分支说明 rehash 后，新的下标与原来下标不等。
                // 将当前下标位置清空。
                tab[i] = null;

                // Unlike Knuth 6.4 Algorithm R, we must scan until
                // null because multiple entries could have been stale.
                // 从 h 位置开始遍历，直到遇到为 null 的元素，并将 rehash 后的元素插入到该位置。
                while (tab[h] != null)
                    h = nextIndex(h, len);
                tab[h] = e;
            }
        }
    }
    
    // i 为 staleSlot 后的第一个 null 元素的位置下标。
    return i;
}

/**
 * Heuristically scan some cells looking for stale entries.
 * This is invoked when either a new element is added, or
 * another stale one has been expunged. It performs a
 * logarithmic number of scans, as a balance between no
 * scanning (fast but retains garbage) and a number of scans
 * proportional to number of elements, that would 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) {
    // 入参 i: 一个已知不为过时 Entry 的下标。扫描从 i 之后的位置开始。
    // 入参 n: 扫描次数控制值
    
    // 是否清理了任意过时 Entry 标志，
    // 为 false 代表本次方法调用未能清理任何过时 Entry，为 true 代表本次方法调用至少清理了一个过时 Entry。
    boolean removed = false;
    ThreadLocal.ThreadLocalMap.Entry[] tab = table;
    int len = tab.length;
    // doWhile 循环，至少执行一次。
    do {
        i = nextIndex(i, len);
        ThreadLocal.ThreadLocalMap.Entry e = tab[i];
        if (e != null && e.get() == null) {
            // 进入到当前分支说明当前 Entry 为过时 Entry。
            // 将 n 置为数组容量，将当前循环遍历次数进行追增（n 变大了）。
            n = len;
            // 将标志置为 true，证明本次方法调用并不是无功而返。
            removed = true;
            // 调用清理过时 Entry 方法，并将 expungeStaleEntry 方法返回的 null 元素的下标赋值给 i，
            // 在这之间的下标都在 expungeStaleEntry 方法中进行了清理，所以这里直接跳过避免重复操作。
            i = expungeStaleEntry(i);
        }
        // >>>= 无符号右移并赋值，相当于除以 2 操作。
    } while ( (n >>>= 1) != 0);
    // 返回本次是否至少清理了一个过时 Entry。
    return removed;
}

/**
 * Replace a stale entry encountered during a set operation
 * with an entry for the specified key.  The value passed in
 * the value parameter is stored in the entry, whether or not
 * an entry already exists for the specified key.
 *
 * As a side effect, this method expunges all stale entries in the
 * "run" containing the stale entry.  (A run is a sequence of entries
 * between two null slots.)
 *
 * @param  key the key
 * @param  value the value to be associated with key
 * @param  staleSlot index of the first stale entry encountered while
 *         searching for key.
 */
private void replaceStaleEntry(ThreadLocal<?> key, Object value,
                               int staleSlot) {
    // 入参 key: set 操作传过来的 key
    // 入参 value: set 操作传过来的 value，与参数 key 相关联
    // 入参 staleSlot: 待替换的过时 Entry 的下标
    
    ThreadLocal.ThreadLocalMap.Entry[] tab = table;
    int len = tab.length;
    ThreadLocal.ThreadLocalMap.Entry e;

    // Back up to check for prior stale entry in current run.
    // We clean out whole runs at a time to avoid continual
    // incremental rehashing due to garbage collector freeing
    // up refs in bunches (i.e., whenever the collector runs).
    // slotToExpunge 变量目标是存储当前区间段（两个 null 元素之间），第一个过时 Entry 的下标。
    // 将入参的过时 Entry 下标赋值给 slotToExpunge。
    int slotToExpunge = staleSlot;
    // 这里需要格外注意一下，这里并不是递增下标，而是对下标进行递减。
    // prevIndex ((i - 1 >= 0) ? i - 1 : len - 1)。
    // 向前进行遍历直到遇到为 null 的元素。
    for (int i = prevIndex(staleSlot, len);
         (e = tab[i]) != null;
         i = prevIndex(i, len))
        if (e.get() == null)
            // 将遍历过程中过时 Entry 的下标赋值给 slotToExpunge 变量。
            // 经过当前遍历逻辑，slotToExpunge 将存储两个 null 元素之间第一个过时 key 的下标。
            slotToExpunge = i;

    // Find either the key or trailing null slot of run, whichever
    // occurs first
    // 这里是由入参的过时 Entry 下标开始向后遍历，直到遇到 null 元素。
    for (int i = nextIndex(staleSlot, len);
         (e = tab[i]) != null;
         i = nextIndex(i, len)) {
        ThreadLocal<?> k = e.get();

        // If we find key, then we need to swap it
        // with the stale entry to maintain hash table order.
        // 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.
        if (k == key) {
            // 进入当前分支表示在遍历的过程中找到了被 set 的 Entry 对象的本体。
            // 将和 key 关联的新 value 值赋值给本体。
            e.value = value;
            // 操作一
            // 将 Entry 对象本体和入参 staleSlot 位置的过时 Entry 进行交换，
            // 结果是set操作的 key 与 value，无论之前本体存储在哪里，
            // 最终都会存储在入参的 staleSlot 下标，符合方法名中的 replace 含义。
            tab[i] = tab[staleSlot];
            tab[staleSlot] = e;

            // Start expunge at preceding stale entry if it exists
            if (slotToExpunge == staleSlot)
                // 如果当前区间段第一个过时 Entry 下标仍是 staleSlot 下标，
                // 那么需要将当前 i 下标赋值给 slotToExpunge ，因为 staleSlot 下标已经存储了 set 操作的 Entry 对象，
                // 导致当前 i 下标变成了第一个过时 Entry 的下标。
                slotToExpunge = i;
            // 先调用 expungeStaleEntry 方法清除 slotToExpunge 下标的过时 Entry，
            // 再从 expungeStaleEntry 方法返回的 null 元素的下标开始执行 cleanSomeSlots 方法。
            cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
            // 已经完成替换过时条目操作，退出当前方法。
            return;
        }

        // If we didn't find stale entry on backward scan, the
        // first stale entry seen while scanning for key is the
        // first still present in the run.
        if (k == null && slotToExpunge == staleSlot)
            // 进入当前分支说明当前 Entry 是过时 Entry。
            // 如果当前区间段第一个过时 Entry 下标仍是入参的 staleSlot 下标，
            // 则需要将当前位置下标赋值给 slotToExpunge，因为最终当前位置的过时 Entry 将是
            // 当前区间段的第一个过时 Entry。因为 staleSlot 下标位置的过时 Entry 在之后的逻辑
            // 里要么被交换到当前下标之后（上文操作一），要么被新的 set 传入的 Entry 覆盖掉（下文操作二）。
            slotToExpunge = i;
    }

    // If key not found, put new entry in stale slot
    // 操作二
    // 代码执行到当前位置说明 set 的 key 与 value 是一个新的 Entry，在之前并不存在。
    // 以 set 方法传入的 key 和 value 值 new 一个新的 Entry 对象，并覆盖在入参的 staleSlot 下标处。
    tab[staleSlot].value = null;
    tab[staleSlot] = new ThreadLocal.ThreadLocalMap.Entry(key, value);

    // If there are any other stale entries in run, expunge them
    if (slotToExpunge != staleSlot)
        // slotToExpunge 与 staleSlot 相等则说明当前区间段只有入参 staleSlot 位置有过时 Entry，
        // 并且该过时 Entry 已被覆盖，所以无需清理，无需进入当前分支。
        
        // 进入当前分支说明当前区间段，除了被覆盖的过时 Entry，至少还存在一个过时 Entry，
        // slotToExpunge 下标为第一个过时 Entry 的下标。
        // 先调用 expungeStaleEntry 方法清除 slotToExpunge 下标的过时 Entry，
        // 再从 expungeStaleEntry 方法返回的 null 元素的下标开始执行 cleanSomeSlots 方法。
        cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
}