ThreadLocal源码解析

/**
* 创建一个ThreadLocal变量
* Creates a thread local variable.
* @see #withInitial(java.util.function.Supplier)
*/
public ThreadLocal() {}

/**
* JDK 1.8 新加入内容, 通过Supplier创建一个ThreadLocal
* (实际上是一个内部类SuppliedThreadLocal, 继承自ThreadLocal)
* 获取时采用Supplier的get()方法
*
* Creates a thread local variable. The initial value of the variable is
* determined by invoking the {@code get} method on the {@code Supplier}.
*
* @param <S> the type of the thread local's value
* @param supplier the supplier to be used to determine the initial value
* @return a new thread local variable
* @throws NullPointerException if the specified supplier is null
* @since 1.8
*/	
public static <S> ThreadLocal<S> withInitial(Supplier<? extends S> supplier) {
    return new SuppliedThreadLocal<>(supplier);
}

//用虚引用封装的ThreadLocal
static class Entry extends WeakReference<ThreadLocal> {
    Object value; // 声明一个值
    Entry(ThreadLocal k, Object v) { // 用ThreadLocal对象和值创建一个Entry
        super(k);
        value = v;
    }
}

import jdk.internal.misc.TerminatingThreadLocal;

import java.lang.ref.*;
import java.util.Objects;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.Supplier;

public class ThreadLocal<T> {
    /**
     * ThreadLocals依赖于附加到每个线程的线性探测哈希映射
     * (thread.ThreadLocals和inheritablethrreadlocals)
     * ThreadLocal对象充当键，通过threadLocalHashCode进行搜索
     * 这是一个自定义散列代码(仅在ThreadLocalMaps中有用)
     * 它消除了在相同线程使用连续构造的threadlocal的常见情况下的冲突
     * 同时在不太常见的情况下保持良好的性能
     *
     * ThreadLocals rely on per-thread linear-probe hash maps attached
     * to each thread (Thread.threadLocals and
     * inheritableThreadLocals).  The ThreadLocal objects act as keys,
     * searched via threadLocalHashCode.  This is a custom hash code
     * (useful only within ThreadLocalMaps) that eliminates collisions
     * in the common case where consecutively constructed ThreadLocals
     * are used by the same threads, while remaining well-behaved in
     * less common cases.
     */
    private final int threadLocalHashCode = nextHashCode();

    /**
     * 下一个hashcode, 原子更新, 从零开始
     * The next hash code to be given out. Updated atomically. Starts at zero.
     */
    private static AtomicInteger nextHashCode = new AtomicInteger();

    /**
     * 连续生成的散列码之间的差异
     * -将隐式顺序线程局部id转换为近似最优分布的乘法散列值
     * 以获得两个大小表的幂
     *
     * The difference between successively generated hash codes - turns
     * implicit sequential thread-local IDs into near-optimally spread
     * multiplicative hash values for power-of-two-sized tables.
     */
    private static final int HASH_INCREMENT = 0x61c88647;

    /**
     * 返回下一个hashcode
     * Returns the next hash code.
     */
    private static int nextHashCode() { 
        return nextHashCode.getAndAdd(HASH_INCREMENT);
    }

    /**
     * 返回此线程局部变量的当前线程“初始值”
     * 此方法将在线程第一次使用{@link#get}方法访问变量时调用
     * 除非线程以前调用了{@link#set}方法，在这种情况下，不会为线程调用{@code initialValue}方法
     * 通常，每个线程最多调用一次此方法，但在随后调用{@link#remove}和{@link#get}时，可能会再次调用此方法
     *
     * Returns the current thread's "initial value" for this
     * thread-local variable.  This method will be invoked the first
     * time a thread accesses the variable with the {@link #get}
     * method, unless the thread previously invoked the {@link #set}
     * method, in which case the {@code initialValue} method will not
     * be invoked for the thread.  Normally, this method is invoked at
     * most once per thread, but it may be invoked again in case of
     * subsequent invocations of {@link #remove} followed by {@link #get}.
     *
     * 此实现只返回{@code null}；
     * 如果程序员希望线程局部变量具有{@code null}以外的初始值
     * 则必须对{@code thread local}进行子类化，并重写此方法。通常，将使用匿名内部类
     *
     * <p>This implementation simply returns {@code null}; if the
     * programmer desires thread-local variables to have an initial
     * value other than {@code null}, {@code ThreadLocal} must be
     * subclassed, and this method overridden.  Typically, an
     * anonymous inner class will be used.
     *
     * @return the initial value for this thread-local
     */
    protected T initialValue() {
        return null;
    }

    /**
     * JDK 1.8新加入的, 通过Supplier创建一个ThreadLocal
     *
     * @param <S> the type of the thread local's value
     * @param supplier the supplier to be used to determine the initial value
     * @return a new thread local variable
     * @throws NullPointerException if the specified supplier is null
     * @since 1.8
     */
    public static <S> ThreadLocal<S> withInitial(Supplier<? extends S> supplier) {
        return new SuppliedThreadLocal<font color="#ff0000">(supplier);
    }

    /**
     * ThreadLocal默认的构造器
     * @see #withInitial(java.util.function.Supplier)
     */
    public ThreadLocal() { }

    /**
     * 返回此线程局部变量的当前线程副本中的值
     * 如果变量没有当前线程的值，则首先将其初始化为调用{@link#initialValue}方法返回的值
     *
     * Returns the value in the current thread's copy of this
     * thread-local variable.  If the variable has no value for the
     * current thread, it is first initialized to the value returned
     * by an invocation of the {@link #initialValue} method.
     *
     * @return the current thread's value of this thread-local
     */
    public T get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t); // 通过当前Thread获得ThreadLocalMap对象
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this); // 通过当前ThreadLocal对象获得ThreadLocalMap.Entry
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        // 如果无法找到对应线程的value值, 则调用setInitialValue()方法将其初始化为null
        return setInitialValue();
    }

    /**
     * 如果此线程局部变量的当前线程副本中有值，则返回true
     * 即使该值为null
     * (即: 没有存值时返回为false; 存了值, 即使为null也返回true, 因为此时会创建一个新的Entry)
     * Returns {@code true} if there is a value in the current thread's copy of
     * this thread-local variable, even if that values is {@code null}.
     *
     * @return {@code true} if current thread has associated value in this
     *         thread-local variable; {@code false} if not
     */
    boolean isPresent() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        return map != null && map.getEntry(this) != null;
    }

    /**
     * set()的另一种实现方式来初始化值;
     * 如果用户重写了set()方法, 则此方法作为原set()方法(进行初始化)
     * 
     * Variant of set() to establish initialValue. Used instead
     * of set() in case user has overridden the set() method.
     *
     * @return the initial value
     */
    private T setInitialValue() {
        T value = initialValue(); // 默认实现返回 null
        Thread t = Thread.currentThread(); // 获取当前线程
        ThreadLocalMap map = getMap(t); // 根据当前线程获取ThreadLocalMap
        if (map != null) { // 如果map不为空(说明之前使用过set, 并完成过初始化), 直接调用map的set
            map.set(this, value);
        } else { // map为空, 创建map
            createMap(t, value);
        }
        if (this instanceof TerminatingThreadLocal) {
            TerminatingThreadLocal.register((TerminatingThreadLocal<?>) this);
        }
        return value;
    }

    /**
     * 将此线程的当前线程副本设置为指定值
     * 大多数子类无需重写此方法，只需依赖initialValue方法来设置线程局部变量的值
     *
     * Sets the current thread's copy of this thread-local variable
     * to the specified value.  Most subclasses will have no need to
     * override this method, relying solely on the {@link #initialValue}
     * method to set the values of thread-locals.
     *
     * @param value the value to be stored in the current thread's copy of
     *        this thread-local.
     */
    public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            map.set(this, value);
        } else {
            createMap(t, value);
        }
    }

    /**
     * 删除此线程局部变量的当前线程值
     * 如果此线程局部变量随后被当前线程get/read，则其值将通过调用其initialValue方法重新初始化
     * 除非其值在中间被当前线程set
     * 这可能导致在当前线程中多次调用initialValue方法
     *
     * Removes the current thread's value for this thread-local
     * variable.  If this thread-local variable is subsequently
     * {@linkplain #get read} by the current thread, its value will be
     * reinitialized by invoking its {@link #initialValue} method,
     * unless its value is {@linkplain #set set} by the current thread
     * in the interim.  This may result in multiple invocations of the
     * {@code initialValue} method in the current thread.
     *
     * @since 1.5
     */
     public void remove() {
         ThreadLocalMap m = getMap(Thread.currentThread());
         if (m != null) {
             m.remove(this);
         }
     }

    /**
     * 获取与ThreadLocal关联的映射
     * 在InheritableThreadLocal中被重写了
     *
     * Get the map associated with a ThreadLocal. Overridden in
     * InheritableThreadLocal.
     *
     * @param  t the current thread
     * @return the map
     */
    ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }

    /**
     * 创建与ThreadLocal关联的映射
     * 在InheritableThreadLocal中被重写
     *
     * Create the map associated with a ThreadLocal. Overridden in
     * InheritableThreadLocal.
     *
     * @param t the current thread
     * @param firstValue value for the initial entry of the map
     */
    void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }

    /**
     * 创建继承的线程局部变量map的工厂方法
     * 设计为仅从Thread的构造方法调用
     *
     * Factory method to create map of inherited thread locals.
     * Designed to be called only from Thread constructor.
     *
     * @param  parentMap the map associated with parent thread
     * @return a map containing the parent's inheritable bindings
     */
    static ThreadLocalMap createInheritedMap(ThreadLocalMap parentMap) {
        return new ThreadLocalMap(parentMap);
    }

    /**
     * childValue方法显式地在子类InheritableThreadLocal中定义
     * 但在这里内部定义是为了提供createInheritedMap 工厂方法
     * 而无需在InheritableThreadLocal中对map类进行子类化
     * 这种技术比在方法中嵌入测试实例的方法更可取
     *
     * Method childValue is visibly defined in subclass
     * InheritableThreadLocal, but is internally defined here for the
     * sake of providing createInheritedMap factory method without
     * needing to subclass the map class in InheritableThreadLocal.
     * This technique is preferable to the alternative of embedding
     * instanceof tests in methods.
     */
    T childValue(T parentValue) {
        throw new UnsupportedOperationException();
    }

    /**
     * 继承自ThreadLocal: 从指定的Supplier获取初始值
     *
     * An extension of ThreadLocal that obtains its initial value from
     * the specified {@code Supplier}.
     */
    static final class SuppliedThreadLocal<T> extends ThreadLocal<T> {

        private final Supplier<? extends T> supplier;

        SuppliedThreadLocal(Supplier<? extends T> supplier) {
            this.supplier = Objects.requireNonNull(supplier);
        }

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

    /**
     * ThreadLocalMap是一个定制的HashMap，仅适用于维护线程本地值
     * 在ThreadLocal类之外不暴露任何方法
     * 该类是包私有的，允许在类线程中声明字段
     * 为了帮助处理非常大且使用寿命长的场景，哈希表条目使用WeakReferences作为键
     * 但是，由于不使用引用队列，因此只有当表开始耗尽空间时，才保证删除过时的条目(存在内存泄漏)
     *
     * ThreadLocalMap is a customized hash map suitable only for
     * maintaining thread local values. No operations are exported
     * outside of the ThreadLocal class. The class is package private to
     * allow declaration of fields in class Thread.  To help deal with
     * very large and long-lived usages, the hash table entries use
     * WeakReferences for keys. However, since reference queues are not
     * used, stale entries are guaranteed to be removed only when
     * the table starts running out of space.
     */
    static class ThreadLocalMap {

        /**
         * ThreadLocalMap的内部类, 用于真正存放ThreadLocal的K-V对
         * 其中Key是ThreadLocal实例, Value是线程的副本
         *
         * 此哈希映射中的Entry继承了WeakReference
         * 使用包含他的类作为键(始终是ThreadLocal对象)
         * 请注意，空键(即entry.get() == null)意味着不再引用该键，因此可以从表中删除该项
         * 这些条目在下面的代码中称为“stale entries”(过时的Entry)
         *
         * The entries in this hash map extend WeakReference, using
         * its main ref field as the key (which is always a
         * ThreadLocal object).  Note that null keys (i.e. entry.get()
         * == null) mean that the key is no longer referenced, so the
         * entry can be expunged from table.  Such entries are referred to
         * as "stale entries" in the code that follows.
         */
        static class Entry extends WeakReference<ThreadLocal<?>> {
            /** The value associated with this ThreadLocal. */
            Object value;

            Entry(ThreadLocal<?> k, Object v) {
                super(k); // 调用WeakReference的构造方法
                value = v;
            }
        }

        /**
         * 容量初值为16, 一定是2的幂!(配合HASH_INCREMENT[0x61c88647]实现hashcode平均分布)
         */
        private static final int INITIAL_CAPACITY = 16;

        /**
         * ThreadLocalMap内部采用Entry的动态数组实现, 进行动态扩容(扩容大小为2的幂)
         *
         * The table, resized as necessary.
         * table.length MUST always be a power of two.
         */
        private Entry[] table;

        /**
         * ThreadLocalMap中Entry的实际数量
         *
         * The number of entries in the table.
         */
        private int size = 0;

        /**
         * 进行下一次扩容的阈值
         */
        private int threshold; // Default to 0

        /**
         * 设置扩容阈值, 其值为len的2/3(内部调用时len就是动态数组table的长度)
         *
         * Set the resize threshold to maintain at worst a 2/3 load factor.
         */
        private void setThreshold(int len) {
            threshold = len * 2 / 3;
        }

        /**
         * 计算 (i + 1) % len
         * Increment i modulo len.
         */
        private static int nextIndex(int i, int len) {
            return ((i + 1 < len) ? i + 1 : 0);
        }

        /**
         * 计算(i + len - 1) % len
         * Decrement i modulo len.
         */
        private static int prevIndex(int i, int len) {
            return ((i - 1 >= 0) ? i - 1 : len - 1);
        }

        /**
         * ThreadLocalMap的构造方法, 根据给定的初始的K-V进行初始化:
         * (初始化类型为Entry的动态数组, 容量为16; 初始化索引i; 初始化threshold为16 * 2/3 = 10)
         * ThreadLocalMaps是懒加载的，我们只在至少有一个条目要放入其中时创建
         * 
         * Construct a new map initially containing (firstKey, firstValue).
         * ThreadLocalMaps are constructed lazily, so we only create
         * one when we have at least one entry to put in it.
         */
        ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
            table = new Entry[INITIAL_CAPACITY];
            int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
            table[i] = new Entry(firstKey, firstValue);
            size = 1;
            setThreshold(INITIAL_CAPACITY);
        }

        /**
         * ThreadLocalMap的构造方法, 根据给定的父ThreadLocalMap进行初始化:
         * 其中包含来自给定父映射的所有可继承线程局部变量
         * (是对于父ThreadLocalMap中table数组各元素的浅复制)
         * 仅由CreateInheriteMap调用
         *
         * Construct a new map including all Inheritable ThreadLocals
         * from given parent map. Called only by createInheritedMap.
         *
         * @param parentMap the map associated with parent thread.
         */
        private ThreadLocalMap(ThreadLocalMap parentMap) {
            Entry[] parentTable = parentMap.table;
            int len = parentTable.length;
            
            // 通过父ThreadLocalMap元素数量初始化扩容阈值
            setThreshold(len);
            // 初始化数组
            table = new Entry[len];

            // 对父ThreadLocalMap中的table进行浅复制
            // 产生新的Entry, 但存放的是原来的Object的索引!
            for (Entry e : parentTable) {
                if (e != null) {
                    @SuppressWarnings("unchecked")
                    ThreadLocal<Object> key = (ThreadLocal<Object>) e.get();
                    if (key != null) {
                        Object value = key.childValue(e.value);
                        // new了Entry, 放入的是父table中的value
                        Entry c = new Entry(key, value);
                        int h = key.threadLocalHashCode & (len - 1);
                        while (table[h] != null)
                            h = nextIndex(h, len);
                        table[h] = c;
                        size++;
                    }
                }
            }
        }

        /**
         * 获取对应key的Entry
         * 此方法本身只处理快速路径: 现有键的直接命中
         * 否则它将转发到getEntryAfterMiss方法
         * 这是为了最大限度地提高性能直接命中，部分通过使这种方法易于链接
         *
         * Get the entry associated with key.  This method
         * itself handles only the fast path: a direct hit of existing
         * key. It otherwise relays to getEntryAfterMiss.  This is
         * designed to maximize performance for direct hits, in part
         * by making this method readily inlinable.
         *
         * @param  key the thread local object
         * @return the entry associated with key, or null if no such
         */
        private Entry getEntry(ThreadLocal<?> key) {
            // 通过hashcode计算索引i
            int i = key.threadLocalHashCode & (table.length - 1);
            Entry e = table[i];
            if (e != null && e.get() == key) // 通过hash槽直接找到了, 则返回
                return e;
            else // hash槽中没找到, 则调用getEntryAfterMiss()方法
                return getEntryAfterMiss(key, i, e);
        }

        /**
         * 在其直接哈希槽中找不到key时使用的getEntry方法(发生了hash冲突)
         * 
         * Version of getEntry method for use when key is not found in
         * its direct hash slot.
         *
         * @param  key the thread local object
         * @param  i the table index for key's hash code
         * @param  e the entry at table[i]
         * @return the entry associated with key, or null if no such
         */
        private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
            Entry[] tab = table;
            int len = tab.length;

            // 当前e不为空
            while (e != null) { 
                ThreadLocal<?> k = e.get(); // 获得当前Entry的key
                if (k == key) // 找到对应key的value, 返回
                    return e;
                if (k == null) // key为null(遇到了脏entry, key为null, 但是value没有被回收)
                    // 调用expungeStaleEntry()方法, 清理掉脏entry
                    expungeStaleEntry(i);
                else // 否则根据当前索引计算下一个索引i
                    i = nextIndex(i, len);
                // 寻找下一个i
                e = tab[i];
            }
            return null;
        }

        /**
         * 设置(添加或修改)给定key的value
         *
         * set方法可能会有的情况:
         * 1. 探测过程中slot都不无效，并且顺利找到key所在的slot，直接替换即可;
         * 2. 探测过程中发现有无效slot，调用replaceStaleEntry
         *     效果是最终一定会把key和value放在这个slot，并且会尽可能清理无效slot;
         *       - 在replaceStaleEntry过程中，如果找到了key，则做一个swap把它放到那个无效slot中，value置为新值
         *       - 在replaceStaleEntry过程中，没有找到key，直接在无效slot原地放entry
         * 3. 探测没有发现key，则在连续段末尾的后一个空位置放上entry，这也是线性探测法的一部分
         *     放完后，做一次启发式清理，如果没清理出去key，并且当前table大小已经超过阈值了，则做一次rehash
         *     rehash函数会调用一次全量清理slot方法也即expungeStaleEntries
         *     如果完了之后table大小超过了threshold - threshold / 4，则进行扩容2倍
         *
         * Set the value associated with key.
         *
         * @param key the thread local object
         * @param value the value to be set
         */
        private void set(ThreadLocal<?> key, Object value) {
            // 不使用get()方法
            // 因为在使用set()方法创建新的Entry时, 需要替换之前的旧的Entry
            // 这使得在get()方法中使用的快速路径会更频繁的失败
            // (我觉得是在方法调用栈等方面的权衡, 最终导致作者用inline又实现了一遍方法)
            
            // We don't use a fast path as with get() because it is at
            // least as common to use set() to create new entries as
            // it is to replace existing ones, in which case, a fast
            // path would fail more often than not.

            // 获得table
            Entry[] tab = table;
            // 获得len
            int len = tab.length;
            // 获得key对应的索引i
            int i = key.threadLocalHashCode & (len-1);

            // 线性探测
            // 基本上又写了一遍get()方法的核心内容...
            for (Entry e = tab[i]; e != null; e = tab[i = nextIndex(i, len)]) {
                ThreadLocal<?> k = e.get();

                if (k == key) { // 找到了key, 修改value;
                    e.value = value;
                    return;
                }

                if (k == null) { // key为null, 替换失效的entry
                    replaceStaleEntry(key, value, i);
                    return;
                }
            }

            // 没有发现key
            tab[i] = new Entry(key, value);
            int sz = ++size;
            // 调用cleanSomeSlots()做一次启发式清理
            // 如果没清理出去key, 并且当前table大小已经超过阈值了, 做一次rehash
            if (!cleanSomeSlots(i, sz) && sz >= threshold)
                // rehash方法会调用一次全量清理slot方法也即expungeStaleEntries
                // 如果完了之后table大小超过了threshold - threshold / 4，则进行扩容2倍
                rehash();
        }

        /**
         * 从map中删除ThreadLocal
         * 直接在table中找key，如果找到了，把弱引用断了做一次段清理
         *
         * Remove the entry for key.
         */
        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;
                }
            }
        }

        /**
         * 用指定key的Entry替换set操作期间遇到的过时Entry
         * 在value中传递的值被存储在Entry中，无论是否已存在指定键的条目
         *
         * 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.
         *
         * 作为副作用，此方法将删除包含替换Entry在内的“运行”中的所有过时Entry
         *（两个空槽之间的条目序列） 
         *
         * 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) {
            Entry[] tab = table;
            int len = tab.length;
            Entry e;

            // 向前扫描，查找最前的一个无效slot
            // 我们一次清理整个运行运行期间的无效Entry
            // 避免由于垃圾收集器释放大量的引用（即每当收集器运行时）而导致持续的增量rehash
            // 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).
            int slotToExpunge = staleSlot;
            for (int i = prevIndex(staleSlot, len);
                 (e = tab[i]) != null;
                 i = prevIndex(i, len))
                if (e.get() == null)
                    slotToExpunge = i;

            // 向后遍历table, 查找key后面的尾随空槽，以先出现的为准
            // Find either the key or trailing null slot of run, whichever occurs first
            for (int i = nextIndex(staleSlot, len);
                 (e = tab[i]) != null;
                 i = nextIndex(i, len)) {
                ThreadLocal<?> k = e.get();

                // 如果找到密钥，则需要将其与陈旧的Entry交换，以维护哈希表顺序
                // 然后，可以将新失效的空槽或其上方遇到的任何其他失效空槽发送到expungeStaleEntry
                // 以删除或重新刷新运行中的所有其他Entry
                // 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) {
                    // 更新对应slot的value值
                    e.value = value;

                    tab[i] = tab[staleSlot];
                    tab[staleSlot] = e;
                    
                    /*
                     * 如果在整个扫描过程中（包括函数一开始的向前扫描与i之前的向后扫描）
                     * 找到了之前的无效slot则以那个位置作为清理的起点，
                     * 否则则以当前的i作为清理起点
                     */
                    if (slotToExpunge == staleSlot)
                        slotToExpunge = i;
                    cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
                    return;
                }

                // 如果当前的slot已经无效，并且向前扫描过程中没有无效slot
                // 则更新slotToExpunge为当前位置
                // 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)
                    slotToExpunge = i;
            }

            // 如果key在table中不存在，则在原地放一个即可
            // If key not found, put new entry in stale slot
            tab[staleSlot].value = null;
            tab[staleSlot] = new Entry(key, value);

            // 在探测过程中如果发现任何无效slot，则做一次清理（连续段清理+启发式清理）
            // If there are any other stale entries in run, expunge them
            if (slotToExpunge != staleSlot)
                cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
        }

        /**
         * ThreadLocal中核心清理方法，它做的事情很简单:
         * 从staleSlot开始遍历，将无效（弱引用指向对象被回收）清理
         * 即对应entry中的value置为null，将指向这个entry的table[i]置为null，直到扫到空entry
         * 另外，在过程中还会对非空的entry作rehash
         * 可以说这个方法的作用就是从staleSlot开始清理连续段中的slot(断开强引用，rehash slot等)
         *
         * 通过重新清除位于过时槽和下一个空槽之间的任何可能发生冲突的Entry来删除过时的Entry
         * 这还将删除在后面的null之前遇到的任何其他过时Entry
         *
         * 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) {
            Entry[] tab = table;
            int len = tab.length;

            // 因为entry对应的ThreadLocal已经被回收，value设为null，显式断开强引用
            tab[staleSlot].value = null;
            // 显式设置该entry为null，以便垃圾回收
            tab[staleSlot] = null;
            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();
                // 清理对应ThreadLocal已经被回收的entry
                if (k == null) {
                    e.value = null;
                    tab[i] = null;
                    size--;
                } else {
                    /*
                      * 对于还没有被回收的情况，需要做一次rehash
                      * 如果对应的ThreadLocal的ID对len取模出来的索引h不为当前位置i
                      * 则从h向后线性探测到第一个空的slot，把当前的entry给挪过去
                      */
                    int h = k.threadLocalHashCode & (len - 1);
                    if (h != i) {
                        tab[i] = null;

                        /*
                         * 在原代码的这里有句注释值得一提，原注释如下：
                         *
                         * Unlike Knuth 6.4 Algorithm R, we must scan until
                         * null because multiple entries could have been stale.
                         *
                         * 这段话提及了Knuth高德纳的著作TAOCP《计算机程序设计艺术》的6.4章节（散列）
                         * 中的R算法
                         * R算法描述了如何从使用线性探测的散列表中删除一个元素
                         * R算法维护了一个上次删除元素的index，当在非空连续段中扫到某个entry的哈希值取模后的索引
                         * 还没有遍历到时，会将该entry挪到index那个位置，并更新当前位置为新的index，
                         * 继续向后扫描直到遇到空的entry
                         *
                         * ThreadLocalMap因为使用了弱引用，所以其实每个slot的状态有三种也即
                         * 有效（value未回收），无效（value已回收），空（entry==null）
                         * 正是因为ThreadLocalMap的entry有三种状态，所以不能完全套高德纳原书的R算法
                         *
                         * 因为expungeStaleEntry函数在扫描过程中还会对无效slot清理将之转为空slot，
                         * 如果直接套用R算法，可能会出现具有相同哈希值的entry之间断开(中间有空entry)
                         */
                        while (tab[h] != null)
                            h = nextIndex(h, len);
                        tab[h] = e;
                    }
                }
            }
            // 返回staleSlot之后第一个空的slot索引
            return i;
        }

        /**
         * 启发式地清理slot,
         * i对应entry是非无效(指向的ThreadLocal没被回收，或者entry本身为空)
         * n是用于控制扫描次数的
         * 正常情况下如果log n次扫描没有发现无效slot，方法就结束了
         * 但是如果发现了无效的slot，将n置为table的长度len，做一次连续段的清理
         * 再从下一个空的slot开始继续扫描
         * 
         * 这个函数有两处地方会被调用:
         * 一处是插入的时候可能会被调用，另外个是在替换无效slot的时候可能会被调用，
         * 区别是前者传入的n为元素个数，后者为table的容量
         *
         * 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) {
            boolean removed = false;
            Entry[] tab = table;
            int len = tab.length;
            do {
                // i在任何情况下自己都不会是一个无效slot，所以从下一个开始判断
                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;
        }

        /**
         * 重新包装和/或调整table的容量
         * 首先扫描整个表以删除过时的Entry
         * 如果这不能充分缩小表的大小(使得数据能够插入, 并且小于threshold)，将表容量增加一倍
         *
         * Re-pack and/or re-size the table. First scan the entire
         * table removing stale entries. If this doesn't sufficiently
         * shrink the size of the table, double the table size.
         */
        private void rehash() {
            // 做一次全量清理
            expungeStaleEntries();

            /*
              * 因为做了一次清理，所以size很可能会变小
              * ThreadLocalMap这里的实现是调低阈值来判断是否需要扩容，
              * threshold默认为len*2/3，所以这里的threshold - threshold / 4相当于len/2
              */
            if (size >= threshold - threshold / 4)
                resize();
        }

        /**
         * 扩容，因为需要保证table的容量len为2的幂，所以扩容即扩大2倍
         * 复制table的元素到newTab，忽略陈旧的元素
         * 假设table中的元素e需要复制到newTab的i位置，如果i位置存在元素，则找下一个空位置进行插入
         *
         * Double the capacity of the table.
         */
        private void resize() {
            Entry[] oldTab = table;
            int oldLen = oldTab.length;
            int newLen = oldLen * 2;
            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; // Help the GC
                    } else {
                        // 线性探测来存放Entry
                        int h = k.threadLocalHashCode & (newLen - 1);
                        while (newTab[h] != null)
                            h = nextIndex(h, newLen);
                        newTab[h] = e;
                        count++;
                    }
                }
            }

            setThreshold(newLen);
            size = count;
            table = newTab;
        }

        /**
         * 做一次全量清理
         * Expunge all stale entries in the table.
         */
        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)
                    /*
                      * 这里可以取返回值，如果大于j的话取了用，这样也是可行的
                      * 因为expungeStaleEntry执行过程中是把连续段内所有无效slot都清理了一遍了
                      */
                    expungeStaleEntry(j);
            }
        }
    }
}

private static final int HASH_INCREMENT = 0x61c88647;
 
private static int nextHashCode() {
   return nextHashCode.getAndAdd(HASH_INCREMENT);
}

/**
 * ThreadLocalMap使用“开放寻址法”中最简单的“线性探测法”解决散列冲突问题
 *
 * @author zk
 */
public class MagicHashCodeTest {

    /**
     * ThreadLocal中定义的hash魔数
     */
    private static final int HASH_INCREMENT = 0x61c88647;

    public static void main(String[] args) {
        // 初始化16
        hashcode(16);
        // 后续2倍扩容
        hashcode(32);
        hashcode(64);
    }

    private static void hashcode(Integer length) {
        var hashcode = 0;
        for (var i = 0; i < length; i++) {
            // 每次递增HASH_INCREMENT
            hashcode = i * HASH_INCREMENT + HASH_INCREMENT;

            //求散列下标，算法公式
            System.out.print(hashcode & (length-1));
            System.out.print(" ");
        }
        System.out.println();
    }
}
------- Output -------
Entry[]初始化容量为16时，元素完美散列:
7 14 5 12 3 10 1 8 15 6 13 4 11 2 9 0
Entry[]容量扩容2倍=32时，元素完美散列:
7 14 21 28 3 10 17 24 31 6 13 20 27 2 9 16 23 30 5 12 19 26 1 8 15 22 29 4 11 18 25 0
Entry[]容量扩容2倍=64时，元素完美散列:
7 14 21 28 35 42 49 56 63 6 13 20 27 34 41 48 55 62 5 12 19 26 33 40 47 54 61 4 11 18 25 32 39 46 53 60 3 10 17 24 31 38 45 52 59 2 9 16 23 30 37 44 51 58 1 8 15 22 29 36 43 50 57 0

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

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

private int expungeStaleEntry(int staleSlot) {
    Entry[] tab = table;
    int len = tab.length;

    //清除当前脏entry
    // expunge entry at staleSlot
    tab[staleSlot].value = null;
    tab[staleSlot] = null;
    size--;

    // Rehash until we encounter null
    Entry e;
    int i;
    //2.往后环形继续查找,直到遇到table[i]==null时结束
    for (i = nextIndex(staleSlot, len);
         (e = tab[i]) != null;
         i = nextIndex(i, len)) {
        ThreadLocal<?> k = e.get();
        //3. 如果在向后搜索过程中再次遇到脏entry，同样将其清理掉
        if (k == null) {
            e.value = null;
            tab[i] = null;
            size--;
        } else {
            //处理rehash的情况
            int h = k.threadLocalHashCode & (len - 1);
            if (h != i) {
                tab[i] = null;

                // Unlike Knuth 6.4 Algorithm R, we must scan until
                // null because multiple entries could have been stale.
                while (tab[h] != null)
                    h = nextIndex(h, len);
                tab[h] = e;
            }
        }
    }
    return i;
}

private void replaceStaleEntry(ThreadLocal<?> key, Object value, int staleSlot) {
    Entry[] tab = table;
    int len = tab.length;
    Entry e;

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

    for (int i = nextIndex(staleSlot, len);
         (e = tab[i]) != null;
         i = nextIndex(i, len)) {
        ThreadLocal<?> k = e.get();

        if (k == key) {
            
            //如果在向后环形查找过程中发现key相同的entry就覆盖并且和脏entry进行交换
2.            e.value = value;
3.            tab[i] = tab[staleSlot];
4.            tab[staleSlot] = e;

            // Start expunge at preceding stale entry if it exists
            //如果在查找过程中还未发现脏entry，那么就以当前位置作为cleanSomeSlots
            //的起点
            if (slotToExpunge == staleSlot)
5.                slotToExpunge = i;
            //搜索脏entry并进行清理
6.            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.
        //如果向前未搜索到脏entry，则在查找过程遇到脏entry的话，后面就以此时这个位置
        //作为起点执行cleanSomeSlots
        if (k == null && slotToExpunge == staleSlot)
7.            slotToExpunge = i;
    }

    // If key not found, put new entry in stale slot
    //如果在查找过程中没有找到可以覆盖的entry，则将新的entry插入在脏entry
8.    tab[staleSlot].value = null;
9.    tab[staleSlot] = new Entry(key, value);

    // If there are any other stale entries in run, expunge them
10.    if (slotToExpunge != staleSlot)
        //执行cleanSomeSlots
11.        cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
}

int slotToExpunge = staleSlot;
for (int i = prevIndex(staleSlot, len);
     (e = tab[i]) != null;
     i = prevIndex(i, len))
    if (e.get() == null)
        slotToExpunge = i;

private void exit() {
    if (group != null) {
        group.threadTerminated(this);
        group = null;
    }
    /* Aggressively null out all reference fields: see bug 4006245 */
    target = null;
    /* Speed the release of some of these resources */
    threadLocals = null;
    inheritableThreadLocals = null;
    inheritedAccessControlContext = null;
    blocker = null;
    uncaughtExceptionHandler = null;
}

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * @author zk
 */
public class DateUtil {

    private static final String DATE_FORMAT = "yyyy-MM-dd HH:mm:ss";

    private static SimpleDateFormat notConcurrentSafeSDF = new SimpleDateFormat(DATE_FORMAT);

    private static ThreadLocal<SimpleDateFormat> concurrentSafeSDF = ThreadLocal.withInitial(() -> new SimpleDateFormat(DATE_FORMAT));

    public static DateFormat getDateFormat() {
        return concurrentSafeSDF.get();
    }

    public static Date parse(String textDate) throws ParseException {
        return getDateFormat().parse(textDate);
    }
}

/**
 * @author zk
 */
public class AutoAddNumber {

    private static ThreadLocal<Integer> seqNum = ThreadLocal.withInitial(() -> 0);

    public static void main(String[] args) {
        AutoAddNumber number = new AutoAddNumber();
        for (int i = 0; i < 4; i++) {
            new ThreadLocalThreadTest(number).start();
        }
    }

    public int getNextNum() {
        seqNum.set(seqNum.get() + 1);
        return seqNum.get();
    }

    static class ThreadLocalThreadTest extends Thread {

        private AutoAddNumber number;

        public ThreadLocalThreadTest(AutoAddNumber number) {
            this.number = number;
        }

        @Override
        public void run() {
            for (int i = 0; i < 5; i++) {
                System.out.println("当前线程是：" + Thread.currentThread().getName() + "对应的编号是:" + number.getNextNum());
            }
        }
    }
}
------- Output -------
当前线程是：Thread-0对应的编号是:1
当前线程是：Thread-0对应的编号是:2
当前线程是：Thread-0对应的编号是:3
当前线程是：Thread-0对应的编号是:4
当前线程是：Thread-0对应的编号是:5
当前线程是：Thread-1对应的编号是:1
当前线程是：Thread-3对应的编号是:1
当前线程是：Thread-3对应的编号是:2
当前线程是：Thread-1对应的编号是:2
当前线程是：Thread-3对应的编号是:3
当前线程是：Thread-1对应的编号是:3
当前线程是：Thread-1对应的编号是:4
当前线程是：Thread-1对应的编号是:5
当前线程是：Thread-3对应的编号是:4
当前线程是：Thread-3对应的编号是:5
当前线程是：Thread-2对应的编号是:1
当前线程是：Thread-2对应的编号是:2
当前线程是：Thread-2对应的编号是:3
当前线程是：Thread-2对应的编号是:4
当前线程是：Thread-2对应的编号是:5