深入浅出 JAVA 之线程 - ThreadLocal 详解

 1public class ThreadLocalDemo {
 2
 3    private static ThreadLocal<Integer> threadLocal = new ThreadLocal<Integer>() {
 4        // 重写 initialValue 方法，初始化线程本地变量的值
 5        @Override
 6        protected Integer initialValue() {
 7            return 0;
 8        }
 9    };
10
11    /**
12     * 线程类
13     */
14    static class MyThread implements Runnable {
15        @Override
16        public void run() {
17            for (int i = 0; i < 3; i++) {
18                try {
19                    // 获取线程本地变量的值
20                    int num = threadLocal.get();
21                    // 操作线程本地变量的值
22                    num += 1;
23                    // 设置线程本地变量的值
24                    threadLocal.set(num);
25                    // 输出线程本地变量的值
26                    System.out.println(Thread.currentThread().getName() + ": " + num);
27                    // 线程暂停，模拟业务操作
28                    Thread.sleep(200);
29                } catch (InterruptedException e) {
30                    e.printStackTrace();
31                    Thread.currentThread().interrupt();
32                }
33            }
34            // 最后调用 remove 方法进行清理
35            threadLocal.remove();
36        }
37    }
38
39    public static void main(String[] args) {
40        MyThread myThread = new MyThread();
41        Thread thread1 = new Thread(myThread, "Thread1");
42        Thread thread2 = new Thread(myThread, "Thread2");
43        thread1.start();
44        thread2.start();
45    }
46
47}

1Thread2: 1
2Thread1: 1
3Thread1: 2
4Thread2: 2
5Thread1: 3
6Thread2: 3

 1import java.text.SimpleDateFormat;
 2import java.util.Date;
 3
 4public class DateFormatThreadLocal {
 5
 6    /**
 7     * 使用 ThreadLocal 包装 SimpleDateFormat
 8     */
 9    private static final ThreadLocal<SimpleDateFormat> DATE_FORMAT_THREAD_LOCAL = new ThreadLocal<SimpleDateFormat>() {
10        @Override
11        protected SimpleDateFormat initialValue() {
12            // 创建 SimpleDateFormat 对象，并指定日期格式
13            return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
14        }
15    };
16    
17    /**
18     * 获取 SimpleDateFormat 实例
19     */
20    public static SimpleDateFormat getDateFormat() {
21        return DATE_FORMAT_THREAD_LOCAL.get();
22    }
23
24    public static void main(String[] args) {
25        String date = getDateFormat().format(new Date());
26        System.out.println(date);
27    }
28
29}

 1/**
 2 * 该属性的作用是作为 Hash 计算的底数
 3 *
 4 * 用户 Hash 计算的底数，在计算线程本地哈希值时混入一个随机数，从而提高哈希值的分布性减少哈希冲突。在 Java
 5 * 的线程池中，每个线程都有一个唯一的 Thread ID (线程ID)，同时又有一个 ThreadLocal 哈希值，它是由当前线
 6 * 程池的 HASH_INCREMENT 值加上线程 ID 计算得出的。因此使用 HASH_INCREMENT 可以保证生成的哈希值是具有
 7 * 一定随机性和唯一性的，可以有效降低哈希冲突的概率，提高哈希表的性能。
 8 */
 9private static final int HASH_INCREMENT = 0x61c88647;
10
11/**
12 * 该属性的作用是用于生成唯一的 HashCode 值分配给 ThreadLocal 实例的 threadLocalHashCode 属性
13 *
14 * nextHashCode() 方法会先获取 nextHashCode 变量的值，然后使用 CAS 操作，将其更新为原值加上固定的增量
15 * (0x61c88647)，最后返回更新后的值。这个增量是随机的，它的目的是使生成的 hash code 分布得更加均匀，以
16 * 减少 hash 冲突的概率。由于使用了 CAS 操作，因此可以保证在多线程环境下唯一性和线程安全性。
17 *
18 * 因此，nextHashCode 属性实际上是 ThreadLocal 类用于生成唯一的 hash code 的关键属性之一，它保证了
19 * 每个 ThreadLocal 实例都拥有唯一的 threadLocalHashCode 值，从而保证了多个线程使用 ThreadLocal
20 * 实例时的独立性和安全性。
21 */
22private static AtomicInteger nextHashCode = new AtomicInteger();
23
24/**
25 * 该属性的作用是用于分配给每个线程的 ThreadLocal 独一无二的 HashCode 值
26 *
27 * 在 ThreadLocal 类中每个 ThreadLocal 实例都有一个 threadLocalHashCode 属性，当线程通过 ThreadLocal
28 * 对象访问本地变量时，ThreadLocal 对象会根据当前线程的 threadLocalHashCode 查找该线程的 ThreadLocalMap
29 * 对象，并通过 ThreadLocalMap 对象获取与该 ThreadLocal 对象关联的本地变量的值。
30 *
31 * 由于每个线程的 threadLocalHashCode 是独一无二的，因此可以确保每个线程都能安全地访问自己的本地变量。因此
32 * threadLocalHashCode 属性实际上是 ThreadLocal 类用于实现线程本地变量的关键属性之一，它保证了每个线程本
33 * 地变量的独立性和安全性。
34 */
35private final int threadLocalHashCode = nextHashCode();

1/**
2 * ThreadLocal 构造方法
3 */
4public ThreadLocal() {
5}

 1/**
 2 * 获取当前线程中 ThreadLocal 对象的值
 3 *
 4 * 获取当前线程中 ThreadLocal 对象关联的值，每个线程获取的都是属于各自线程的 ThreadLocal 对象关联的值，从
 5 * 而实现了多线程之间的数据隔离。当然，如果当前线程没有设置值，那么当前线程在调用 get() 方法获取值时就会调
 6 * 用 initialValue() 方法初始化一个值。
 7 *
 8 * @return 当前线程中 ThreadLocal 对象关联的值。
 9 */
10public T get() {
11    // 获取当前线程对象
12    Thread t = Thread.currentThread();
13    // 调用 getMap() 方法获取当前线程的 ThreadLocalMap 对象
14    ThreadLocalMap map = getMap(t);
15    // 判断当前线程的 ThreadLocalMap 对象是否为空
16    if (map != null) {
17        // 调用 ThreadLocalMap 的 getEntry() 方法，获取与当前 ThreadLocal 对象相关联的 Entry 对象
18        ThreadLocalMap.Entry e = map.getEntry(this);
19        // 判断获取到的 Entry 对象是否为空，如果不为空则将得到的值强制转换为泛型 T，然后返回转换后的值
20        if (e != null) {
21            @SuppressWarnings("unchecked")
22            T result = (T)e.value;
23            return result;
24        }
25    }
26    // 若前面的步骤都没有获取到值，则调用 setInitialValue() 方法设置一个初始值，并返回该值。
27    return setInitialValue();
28}

 1/**
 2 * 设置当前线程 ThreadLocal 对象的初始值
 3 *
 4 * @return 当前线程 ThreadLocal 对象的初始值。
 5 */
 6private T setInitialValue() {
 7    // 调用 initialValue() 方法生成一个初始值
 8    T value = initialValue();
 9    // 获取当前线程对象
10    Thread t = Thread.currentThread();
11    // 调用 getMap() 方法获取当前线程的 ThreadLocalMap 对象
12    ThreadLocalMap map = getMap(t);
13    // 判断当前线程的 ThreadLocalMap 对象是否为空
14    //  - 如果当前线程的 ThreadLocalMap 对象不为空，则调用 set() 方法为 ThreadLocal 对象设置值。
15    //  - 如果当前线程的 ThreadLocalMap 对象为空，则调用 createMap() 方法创建一个 ThreadLocalMap 对象，
16    //    并将 ThreadLocal 对象设置到其中。
17    if (map != null) {
18        map.set(this, value);
19    } else {
20        createMap(t, value);
21    }
22    //  判断当前 ThreadLocal 对象是否是 TerminatingThreadLocal 类的实例。
23    if (this instanceof TerminatingThreadLocal) {
24        // 果当前 ThreadLocal 对象是 TerminatingThreadLocal 类的实例，则调用 register() 方法
25        // 将其注册到 TerminatingThreadLocal 的列表中，以便在线程结束时执行相应的操作。
26        TerminatingThreadLocal.register((TerminatingThreadLocal<?>) this);
27    }
28    return value;
29}

 1/**
 2 * 删除当前线程中 ThreadLocal 对象所对应的值
 3 *
 4 * 调用 remove() 方法后，当前线程 ThreadLocal 对象不再持有任何值，下次访问该线程局部变量时将返回其初始值
 5 * (如果有的话) 或者 null。该方法的主要作用是清除当前线程中的线程局部变量的值，以防止内存泄漏或不必要的持有。
 6 *
 7 * 注意:
 8 * ① 如果线程结束或线程被回收，线程局部变量的值也会被自动移除，因此通常不需要显式调用 remove() 方法。然而在
 9 * 某些情况下，当线程仍然活动时则需要手动清除线程局部变量的值，以避免潜在的问题。
10 * ② remove() 方法是在当前线程中进行清除操作的，而不是在其他线程中进行。因此当多个线程同时使用同一个 ThreadLocal
11 * 变量时，每个线程都需要进行 remove() 操作，以确保 ThreadLocal 变量和对应的值能够被正确清除。
12 */
13public void remove() {
14    // 调用 getMap() 方法获取当前线程的 ThreadLocalMap 对象
15    ThreadLocalMap m = getMap(Thread.currentThread());
16    // 判断当前线程的 ThreadLocalMap 对象是否为 null
17    if (m != null) {
18        // 如果不为 null 则从 ThreadLocalMap 中移除当前线程中 ThreadLocal 对象所对应的值
19        m.remove(this);
20    }
21}

 1/**
 2 * 设置当前线程中 ThreadLocal 对象所对应的值
 3 *
 4 * 在使用 ThreadLocal 对象时每个线程都会维护一个 ThreadLocalMap 对象，并在该对象中存储以 ThreadLocal
 5 * 对象做为 Key，然后存储与该线程的 ThreadLocal 对象所对应的值。当调用 ThreadLocal 的 set() 方法时，
 6 * 会先获取当前线程的 ThreadLocalMap 对象，然后将该 ThreadLocal 对象与指定的值作为键值对，存储到
 7 * ThreadLocalMap 中。
 8 *
 9 * 由于 ThreadLocal 对象是线程隔离的，即每个线程都有自己的 ThreadLocalMap 对象，因此在多线程环境中，
10 * 通过 ThreadLocal 对象可以轻松地实现线程间的变量传递，而不需要使用 synchronized 等线程同步机制，
11 * 从而提高程序的并发性能。
12 *
13 * 需要注意的是，在使用 ThreadLocal 对象时建议在使用结束后尽早清除该对象对应的值，可以使用 ThreadLocal
14 * 的 remove()方法进行清除。如果忘记清除 ThreadLocal 对象的值，则有可能会导致内存泄漏等问题。
15 *
16 * @param value 要存储在当前线程的值
17 */
18public void set(T value) {
19    // 获取当前线程对象
20    Thread t = Thread.currentThread();
21    // 调用 getMap() 方法获取当前线程的 ThreadLocalMap 对象
22    ThreadLocalMap map = getMap(t);
23    // 判断 ThreadLocalMap 是否为空
24    // - 如果不为 null，则调用 set() 方法将当前 ThreadLocal 对象和值存储在映射中；
25    // - 如果为 null，则调用 createMap() 方法创建一个新的 ThreadLocalMap 对象，
26    //   并将当前 ThreadLocal 对象和值存储在其中，并将其与当前线程关联；
27    if (map != null) {
28        map.set(this, value);
29    } else {
30        createMap(t, value);
31    }
32}

 1/**
 2 * 初始化 ThreadLocal 值
 3 *
 4 * 在使用 ThreadLocal 变量时，如果当前线程尚未为该变量设置过值，则会调用该方法为其设置一个初始值。一般情
 5 * 况下我们以定义一个 ThreadLocal 变量，然后继承 ThreadLocal 类并覆盖 initialValue() 方法，来自定
 6 * 义 ThreadLocal 变量的初始值。
 7 *
 8 * @return 初始化的 ThreadLocal 值。
 9 */
10protected T initialValue() {
11    return null;
12}

1/**
2 * 生成下一个 HashCode 值
3 */
4private static int nextHashCode() {
5    return nextHashCode.getAndAdd(HASH_INCREMENT);
6}

 1/**
 2 * 获取一个线程的 ThreadLocalMap 对象
 3 *
 4 * @param t 线程对象 (默认是当前线程)
 5 * @return 线程关联的 ThreadLocalMap 集合
 6 */
 7ThreadLocalMap getMap(Thread t) {
 8    // 获取指定线程的 ThreadLocalMap 对象
 9    return t.threadLocals;
10}

 1/**
 2 * 创建一个继承父线程的 ThreadLocalMap 的副本
 3 *
 4 * 当一个线程创建子线程时，子线程通常会继承父线程的 ThreadLocal 变量。而 createInheritedMap 方法的作用是在子线程
 5 * 中创建一个与父线程中相同的 ThreadLocalMap 对象，并将父线程的 ThreadLocalMap 对象中的键值对复制到新的对象中去。
 6 * 这样子线程就可以在自己的 ThreadLocalMap 中找到与父线程相同的 ThreadLocal 变量，并进行访问和修改。
 7 *
 8 * 这个方法通常在创建子线程时由 JVM 内部调用，以确保子线程继承了父线程的 ThreadLocal 变量。
 9 *
10 * @param parentMap 与父线程关联的 ThreadLocalMap
11 * @return 包含父级可继承绑定的 ThreadLocalMap
12 */
13static ThreadLocalMap createInheritedMap(ThreadLocalMap parentMap) {
14    return new ThreadLocalMap(parentMap);
15}

 1/**
 2 * 创建并初始化当前线程的 ThreadLocalMap 对象。
 3 *
 4 * 在调用 createMap 方法后，首先会创建一个新的 ThreadLocalMap 对象，并将该对象赋给当前线程的 threadLocals 变量。
 5 * 然后将指定的ThreadLocal 对象和对应的初始值放入 ThreadLocalMap 中。
 6 *
 7 * @param t 当前线程
 8 * @param firstValue ThreadLocalMap 集合中要插入的第一个值
 9 */
10void createMap(Thread t, T firstValue) {
11    t.threadLocals = new ThreadLocalMap(this, firstValue);
12}

 1/**
 2 * ThreadLocalMap 初始容量
 3 */
 4private static final int INITIAL_CAPACITY = 16;
 5
 6/**
 7 * 底层数据结构，使用数组表示存储 Entry 对象。
 8 */
 9private Entry[] table;
10
11/**
12 * 集合中 Entry 对象数量
13 */
14private int size = 0;

 1/**
 2 * ThreadLocalMap 构造方法
 3 *
 4 * 构造一个包含初始 Entry(firstKey, firstValue) 的新的 ThreadLocalMap。因为 ThreadLocalMap 是惰性构造的，
 5 * 所以需要至少存入一个 Entry 对象时，才执行创建操作。
 6 */
 7ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
 8    // 创建一个长度为 INITIAL_CAPACITY 的 Entry 类型数组 table，用于存储 ThreadLocal 与其对应值的映射关系
 9    table = new Entry[INITIAL_CAPACITY];
10    // 将分配给 ThreadLocal 对象的 HashCode 值与 INITIAL_CAPACITY-1 进行与运算，计算第一个 Entry 对象存放的位置
11    int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
12    // 创建 Entry 对象，并将其存储在 table 数组中 i 的位置
13    table[i] = new Entry(firstKey, firstValue);
14    // 将 ThreadLocalMap 集合大小设置为 1
15    size = 1;
16    // 根据数组长度和装载因子，计算并设置扩容阈值
17    setThreshold(INITIAL_CAPACITY);
18}

 1/**
 2 * 根据父线程关联的 ThreadLocalMap 创建 ThreadLocalMap 的构造方法
 3 *
 4 * 构造一个新 ThreadLocalMap，包括来自与父线程关联的 ThreadLocalMap 中所有可继承 ThreadLocal 对象。
 5 *
 6 * @param parentMap 与父线程关联的 ThreadLocalMap
 7 */
 8private ThreadLocalMap(ThreadLocalMap parentMap) {
 9    // 获取父线程的 ThreadLocalMap 中的 table 数组并赋给变量 parentTable
10    Entry[] parentTable = parentMap.table;
11    // 使用 len 变量记录父线程 ThreadLocalMap 中数组 table 的长度
12    int len = parentTable.length;
13    // 根据父线程 table 的长度 len 计算新建的当前线程 ThreadLocal 关联的 ThreadLocalMap 的阈值
14    setThreshold(len);
15    // 创建新的长度为 len 的 Entry 数组作为当前当前线程 ThreadLocal 关联的 ThreadLocalMap 的 table 数组
16    table = new Entry[len];
17
18    // 遍历父线程的 parentTable 数组
19    for (Entry e : parentTable) {
20        // 判断数组中的元素 Entry 是否为空
21        if (e != null) {
22            @SuppressWarnings("unchecked")
23            // 获取父类线程 Entry 对象的 key (即ThreadLocal对象)
24            ThreadLocal<Object> key = (ThreadLocal<Object>) e.get();
25            // 如果 key 不为 null，则执行下面操作:
26            if (key != null) {
27                // 将该父类 Entry 中的值赋给变量 value;
28                Object value = key.childValue(e.value);
29                // 创建 Entry 对象并设置对象的 key 和 value 都和父类 Entry 对象的 key 和 value 保持一致;
30                Entry c = new Entry(key, value);
31                // 计算存储新创建的 Entry 对象在数组 table 中的位置
32                int h = key.threadLocalHashCode & (len - 1);
33                // 判断存储新创建 Entry 对象的数组位置是否为 null，如果不是则说明发生哈希冲突，使用开放寻址法
34                // 继续向后寻找空的位置，找到后将对象 Entry 存入到该位置。
35                while (table[h] != null) {
36                    h = nextIndex(h, len);
37                }
38                table[h] = c;
39                // 使当前线程的 ThreadLocal 关联的 ThreadLocalMap 的大小 +1。
40                size++;
41            }
42        }
43    }
44}

 1/**
 2 * ThreadLocalMap 扩容方法
 3 */
 4private void rehash() {
 5    // 先调用 expungeStaleEntries() 方法来清除 ThreadLocalMap 中过期的 Entry 对象，避免内存泄漏
 6    expungeStaleEntries();
 7
 8    // ThreadLocalMap 的负载因子已经超过了阈值的 75%，那么就将哈希表的长度加倍。这里为了避免阈值的惯性滞
 9    // 后效应，使用了 25% 的下调阈值大小，这样在扩容后就可以保证下一次再进行扩容时不必等到 ThreadLocalMap
10    // 的所有条目都被填满才开始扩容。
11    if (size >= threshold - threshold / 4) {
12        // 执行真正执行扩容操作的方法
13        resize();
14    }
15}

 1/**
 2 * 清除 ThreadLocalMap 中过期的 Entry 对象
 3 *
 4 * 由于 ThreadLocalMap 中的 Entry 对象是使用 WeakReference 弱引用来实现的，因此当 ThreadLocal 对象被回
 5 * 收后，对应的 Entry 对象也会被回收，但是由于 WeakReference 的特殊性质，这个对象有可能并没有被及时回收掉，
 6 * 因此需要定期清理。而该方法就是用于清理这些过期的 Entry 对象的，执行时会遍历 ThreadLocalMap 中所有的 Entry
 7 * 对象，找到已经过期的 Entry 对象，并将其清除，从而保证 ThreadLocalMap 中只保留当前还有用的 Entry 对象。
 8 */
 9private void expungeStaleEntries() {
10    // 获取当前 Map 中的 Entry 数组
11    Entry[] tab = table;
12    // 获取 Entry 数组的长度
13    int len = tab.length;
14    // 遍历所有的 Entry
15    for (int j = 0; j < len; j++) {
16        // 获取当前位置的 Entry
17        Entry e = tab[j];
18        // 判断 Entry 是否为 null 并且其 key 对应的对象已经被 GC 回收
19        // 如果是则调用 expungeStaleEntry 方法删除该 Entry
20        if (e != null && e.get() == null) {
21            expungeStaleEntry(j);
22        }
23    }
24}

 1/**
 2 * 计算下一个索引位置，当前方法用于实现 ThreadLocalMap 中 index 计数器的递增和循环使用
 3 *
 4 * 该方法接收两个参数,分别是:
 5 *  - i: 表示当前的 index 值;
 6 *  - len: 表示数组的长度;
 7 * 在当前方法中，先将 i+1 的值与 len 取模，然后返回计算后的结果。如果 i+1 的值等于 len 则执行
 8 * nextIndex(i, len) 返回 0，表示 ThreadLocalMap 的 index 计数器循环中断，需要重置为 0，
 9 * 以便接下来的使用。通过当前方法 ThreadLocalMap 可以实现递增计数器并象征性循环使用 index 计
10 * 数器的功能。
11 */
12private static int nextIndex(int i, int len) {
13    return ((i + 1 < len) ? i + 1 : 0);
14}

 1/**
 2 * 计算上一个索引位置，当前方法用于实现 ThreadLocalMap 中 index 计数器的递减和循环使用
 3 *
 4 * 该方法同样接收两个参数，分别是:
 5 *  - i: 表示当前的 index 值;
 6 *  - len: 表示数组的长度;
 7 * 在当前方法中，先将 i-1 的值与 0 比较，如果 i-1 大于等于 0 则返回计算后的结果，否则返回 len-1。
 8 * 如果 i-1 的值为 0 则返回 len-1，表示 ThreadLocalMap 的 index 计数器循环中断，需要重置为
 9 * len-1，以便接下来的使用。通过当前方法 ThreadLocalMap 可以实现递减计数器并循环使用 index 计
10 * 数器的功能。
11 */
12private static int prevIndex(int i, int len) {
13    return ((i - 1 >= 0) ? i - 1 : len - 1);
14}

 1/**
 2 * 获取给定 ThreadLocal 对象的 Entry 对象
 3 *
 4 * Entry 对象是 ThreadLocalMap 类中的一个内部类，由键值对构成，其 Key 是弱引用的 ThreadLocal 对象，其值为
 5 * Object 类型。当一个 ThreadLocal 对象没有被其它对象所引用时，它就会被垃圾回收器回收，并且对应的 Entry 对象
 6 * 也会被删除。
 7 *
 8 * @param key 与线程关联的 ThreadLocal 对象
 9 * @return 如果查找到则返回对应的 Entry 对象，如果未找到则返回 null
10 */
11private Entry getEntry(ThreadLocal<?> key) {
12    // 获取 ThreadLocalMap 的 HashCode，然后使该 HashCode 与 table 数组长度进行与计算，计算出其在数组中的位置
13    int i = key.threadLocalHashCode & (table.length - 1);
14    // 获取 table 数组中计算位置的 Entry 对象
15    Entry e = table[i];
16    // 判断 Entry 对象是否不为 null，并且 Entry 的 key 和传入的 key 一致:
17    //  - 如果满足条件，则返回该 Entry 对象;
18    //  - 如果不满足条件，则调用 getEntryAfterMiss 方法，从 i 位置向后继续查找 Entry 对象;
19    if (e != null && e.get() == key) {
20        return e;
21    } else {
22        return getEntryAfterMiss(key, i, e);
23    }
24}

 1/**
 2 * 该方法用于在哈希冲突的情况下，查找指定 ThreadLocal 对象对应的 Entry 对象
 3 *
 4 * @param key 要查找的 ThreadLocal 对象
 5 * @param i 指定 ThreadLocal 对象在数组中的下标位置
 6 * @param e 数组 i 位置存储的 Entry 对象
 7 * @return 如果查找到则返回对应的 Entry 对象，如果未找到则返回 null
 8 */
 9private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
10    // 将 ThreadLocalMap 中的数组 table 赋给变量 tab
11    Entry[] tab = table;
12    // 使用 len 变量记录 ThreadLocalMap 中数组 table 的长度
13    int len = tab.length;
14    // 循环查找指定 ThreadLocal 对象对应的 Entry 对象
15    while (e != null) {
16        ThreadLocal<?> k = e.get();
17        // 如果 k 和要查找的 key 相同，则说明找到了对应的 Entry 对象，直接将该对象返回
18        if (k == key) {
19            return e;
20        }
21        // 如果 Entry 对象的 key 为 null，则说明当前 Entry 已经过期，直接调用 expungeStaleEntry 清除该对象
22        if (k == null) {
23            expungeStaleEntry(i);
24        }
25        // 指向下个位置
26        else {
27            i = nextIndex(i, len);
28        }
29        // 将下个位置 i 中的 Entry 对象赋给变量 e
30        e = tab[i];
31    }
32    // 如果遍历到最后都没有找到，则默认返回 null
33    return null;
34}

 1/**
 2 * 从当前线程的 ThreadLocalMap 中根据传入的 ThreadLocal 对象删除指定的 Entry
 3 *
 4 * @param key 需要删除的 ThreadLocal 对象
 5 */
 6private void remove(ThreadLocal<?> key) {
 7    // 将 ThreadLocalMap 中的数组 table 赋给变量 tab
 8    Entry[] tab = table;
 9    // 使用 len 变量记录 ThreadLocalMap 中数组 table 的长度
10    int len = tab.length;
11    // 将传入的 ThreadLocal 对象的 HashCode 与 len-1 进行按位与运算，计算出该对象 Entry 在数组中的下标位置
12    int i = key.threadLocalHashCode & (len-1);
13    // 从 table 数组中的 i 位置开始,往后遍历查找与传入 key 相同的 entry 对象。这里之所以是从 i 位置开始往后遍
14    // 历查找，主要是因为 ThreadLocalMap 中解决哈希冲突的方法为开放寻址法，即插入数据发生哈希冲突时，继续往后寻
15    // 找空的位置来存放该插入的数据，这样来解决哈希冲突。所以，查找数据时也需要从计算出的位置，往后遍历查找才行。
16    for (Entry e = tab[i]; e != null; e = tab[i = nextIndex(i, len)]) {
17        // 判断 Entry 的 key 是否和传入的 key 相同，如果相同则清除该 Entry 对象
18        if (e.get() == key) {
19            // 设置 Entry 的 key ThreadLocal 对象的引用为 null，便于下次 GC 回收该对象
20            e.clear();
21            // 清除 Entry 对象
22            expungeStaleEntry(i);
23            return;
24        }
25    }
26}

 1/**
 2 * 执行清除当前线程 ThreadLocal 对象中过期 Entry 的方法
 3 *
 4 * @param staleSlot 需要清除的数组下标位置
 5 * @return 最后一个遍历到的数组下标
 6 */
 7private int expungeStaleEntry(int staleSlot) {
 8    // 将 ThreadLocalMap 中的数组 table 赋给变量 tab
 9    Entry[] tab = table;
10    // 使用 len 变量记录 ThreadLocalMap 中数组 table 的长度
11    int len = tab.length;
12
13    // 将 staleSlot 位置的 Entry 对象的值设置为 null
14    tab[staleSlot].value = null;
15    // 将 staleSlot 位置的 Entry 对象设置为 null
16    tab[staleSlot] = null;
17    // 将 ThreadLocalMap 大小减少 1
18    size--;
19
20    // 定义变量 e 来记录当前正在遍历的 Entry 对象
21    Entry e;
22    // 定义一个局部变量 i 来记录当前正在遍历的数组下标
23    int i;
24    // 循环遍历数组，从 staleSlot 的下一个位置开始。
25    // 如果当前位置的 Entry 对象不为 null，则使用变量 e 记录该对象，并将下标 i 更新为下一个不为 null 的位置。
26    for (i = nextIndex(staleSlot, len); (e = tab[i]) != null; i = nextIndex(i, len)) {
27        // 获取 e 对象中存储 key，即 ThreadLocal 对象，将其赋给变量将 k
28        ThreadLocal<?> k = e.get();
29        // 判断 ThreadLocal 对象是否为 null:
30        // - 如果是 null，则表示该 entry 已经过期，需要将 value 和数组下标位置都设置为 null;
31        // - 如果不是 null，则表示该条目未过期，需要检查其存储位置是否正确;
32        if (k == null) {
33            // 将 e 对象的 value 设置为 null
34            e.value = null;
35            // 将 tab 数组中下标为 i 的元素设置为 null
36            tab[i] = null;
37            // 将 ThreadLocal 关联的 ThradLocalMap 大小减 1
38            size--;
39        } else {
40            // 根据 ThreadLocal 对象的 hashCode 值计算出该对象应该存储在数组中的位置 h
41            int h = k.threadLocalHashCode & (len - 1);
42            // 如果 h 与当前位置 i 不同，则表示该 Entry 对象存储的位置不正确
43            if (h != i) {
44                // 将当前位置 i 的元素设置为 null
45                tab[i] = null;
46                // 从位置 h 开始向后遍历数组，直到找到一个空闲的位置，然后将该位置赋给变量 h
47                while (tab[h] != null) {
48                    h = nextIndex(h, len);
49                }
50                // 将 e 对象存储在数组空闲位置 h 中
51                tab[h] = e;
52            }
53        }
54    }
55    // 返回最后一个遍历到的数组下标
56    return i;
57}

 1/**
 2 * 设置与当前线程 ThreadLocal 对象关联的值
 3 * 
 4 * 如果当前线程还没有该 ThreadLocal 对象的值则将值设置到该对象中，否则将新值替换为当前值。
 5 *
 6 * 该方法内部会先获取当前线程的 ThreadLocalMap 对象，然后通过 key 的 hashCode() 方法获取 HashCode，再根据 HashCode 
 7 * 在 ThreadLocalMap 对象中查找对应 Entry 对象。如果该 Entry 对象为空，则创建一个新的 Entry 对象并添加到 ThreadLocalMap
 8 * 对象中，否则将新值设置到 Entry 对象中。
 9 *
10 * @param key 当前线程 ThreadLocal 对象
11 * @param value 与 ThreadLocal 对象关联的值
12 */
13private void set(ThreadLocal<?> key, Object value) {
14    // 将 ThreadLocalMap 中的数组 table 赋给变量 tab
15    Entry[] tab = table;
16    // 使用 len 变量记录 ThreadLocalMap 中数组 table 的长度
17    int len = tab.length;
18    // 使用线程的 ThreadLocal 中的 HashCode 值与 len-1 进行与操作，计算出当前 Entry 要存储在数组中的下标位置
19    int i = key.threadLocalHashCode & (len-1);
20
21    // 执行循环，从数组 i 位置开始获取该位置中对应的 Entry 对象，然后进行下面的一些判断操作，如果本次循环没有执
22    // 行 return，则获取下一个位置的 Entry 对象进行判断，直至某次循环过程中执行 return 返回，或者到末尾后 Entry
23    // 对象为 null，才会终止循环。
24    for (Entry e = tab[i]; e != null; e = tab[i = nextIndex(i, len)]) {
25        // 获取当前位置的 Entry 对象中的 key，即 ThreadLocal 对象
26        ThreadLocal<?> k = e.get();
27        // 如果当前 k 就是要查找的 key，相当于找到了对应的 ThreadLocal 对象所在下标位置，将该 Entry 对象的值设置
28        // 为传入的 value，然后返回。
29        if (k == key) {
30            e.value = value;
31            return;
32        }
33        // 如果 Entry 对象的 key 为 null，则说明当前 Entry 已经过期，直接调用 expungeStaleEntry 清除该对象，然
34        // 后方法返回。
35        if (k == null) {
36            replaceStaleEntry(key, value, i);
37            return;
38        }
39    }
40    // 如果走到这一步，相当于目前当前线程 ThreadLocalMap 中不存在用该 ThreadLocal 对象作为 key 的 Entry。所以，这
41    // 里新创建一个 Entry 对象，并将传入的 key 和 value 作为新 Entry 的 key 和 value。
42    tab[i] = new Entry(key, value);
43    // 使 ThreadLocalMap 大小+1
44    int sz = ++size;
45    // 清理一下从 i 位置到 sz 位置中的过期的 Entry 对象，然后判断 sz 大小是否达到了设置的阈值 threshold，如果达到了
46    // 就调用 rehash 方法尝试扩容。
47    if (!cleanSomeSlots(i, sz) && sz >= threshold) {
48        rehash();
49    }
50}

 1/**
 2 * 该方法主要作用是将一个已经过期的 Entry 替换为一个新的 Entry
 3 *
 4 * 该方法会在 ThreadLocalMap 中查找 key 对应的 Entry 对象，查找是否存在:
 5 *  - 如果存在，则将 value 赋值给该 Entry 对象的 value 属性，然后清理过期 Entry 对象工作；
 6 *  - 如果不存在，则会创建一个新的 Entry 对象，并将其插入到 staleSlot 指定的位置，同时将 ThreadLocalMap 中
 7 *    对应的 Entry 对象标记为过期，最好执行清理 Entry 工作。
 8 * 该方法的作用是保证当 ThreadLocal 对象对应的 Entry 过期后，下一次访问该 ThreadLocal 对象时能够正确地插入
 9 * 新的值。在并发场景下，多线程可能同时访问和修改 ThreadLocalMap 对象，如果没有正确地处理过期的条目，可能会导
10 * 致程序出现非预期的行为。因此该方法在保证线程安全性的同时，也保证了 ThreadLocal 对象的正确性。
11 *
12 * @param key 需要设置的键 (表示要操作的 ThreadLocal 对象)
13 * @param value 需要设置的值 (表示与对应 ThreadLocal 关联的值)
14 * @param staleSlot 表示需要替换的过期的 Entry 位置
15 */
16private void replaceStaleEntry(ThreadLocal<?> key, Object value, int staleSlot) {
17    // 将 ThreadLocalMap 中的数组 table 赋给变量 tab
18    Entry[] tab = table;
19    // 使用 len 变量记录 ThreadLocalMap 中数组 table 的长度
20    int len = tab.length;
21    // 定义变量 e 来记录当前正在遍历的 Entry 对象
22    Entry e;
23
24    // 定义变量 slotToExpunge 记录需要清除的位置
25    int slotToExpunge = staleSlot;
26    // 向前遍历数组，直到遍历到 Entry 为 null 时结束。
27    // --- 注: 遍历过程主要是为了查找已经过期的 Entry (key为null就是过期)，如果遇到过期的 Entry 就记录下该 Entry
28    // 所在的数组下标位置。如果遍历过程中存在多个过期的 Entry，那么只记录最后一个过期 Entry 所在的数组下标位置。
29    for (int i = prevIndex(staleSlot, len); (e = tab[i]) != null; i = prevIndex(i, len)) {
30        if (e.get() == null) {
31            slotToExpunge = i;
32        }
33    }
34
35    // 向后遍历数组，直到遍历到 Entry 为 null，或者遇到 Entry 的 key 和传入的 key 相同时结束。
36    // --- 注: 遍历过程主要是为了寻找需要被清理的位置，便于执行清理过期 Entry。
37    for (int i = nextIndex(staleSlot, len);  (e = tab[i]) != null; i = nextIndex(i, len)) {
38        // 获取 e 对象中存储 key，即 ThreadLocal 对象，将其赋给变量将 k
39        ThreadLocal<?> k = e.get();
40
41        // 如果当前位置 Entry 对象的 key 和传入的 key 相同，则:
42        // ① 在直接将当前的 Entry 对象的值设置为传入的 value;
43        // ② 将当前位置与过期 Entry 的位置进行交换，以保持哈希表的顺序;
44        // ③ 判断 slotToExpunge 是否等于传入的过期 Entry 所在位置 staleSlot，是则设置变量 slotToExpunge
45        // 中记录的需要被清理位置为 i;
46        // ④ 执行 Entry 的清理清理工作;
47        if (k == key) {
48            // ①
49            e.value = value;
50            // ②
51            tab[i] = tab[staleSlot];
52            tab[staleSlot] = e;
53            // ③
54            // 注: 之所以设置 slotToExpunge = i，主要是在 i 和 staleSlot 位置的 Entry 进行了交换，为了保证变量
55            // slotToExpunge 中记录的清理位置的正确性，需要将变量 slotToExpunge 中记录的位置 staleSlot 变为位
56            // 置 i，因为交换后位置 i 才是那个已经过期需要被回收的 Entry 对象。
57            if (slotToExpunge == staleSlot) {
58                slotToExpunge = i;
59            }
60            // ④
61            cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
62            return;
63        }
64
65        // 如果当前位置 Entry 对象的 key 为 null，则说明当前 Entry 已经过期，再判断 slotToExpunge 中记录的清除
66        // 的位置是否是传入的过期 Entry 所在位置，如果是则设置变量 slotToExpunge 中记录的清除的位置为当前位置 i。
67        if (k == null && slotToExpunge == staleSlot) {
68            slotToExpunge = i;
69        }
70    }
71
72    // 如果传入的 key 所在位置没有找到，则创建一个新的 Entry 对象插入到数组 stableSlot 位置。
73    tab[staleSlot].value = null;
74    tab[staleSlot] = new Entry(key, value);
75
76    // 如果记录的需要清除的位置并不是传入的过期 Entry 所在位置 staleSlot，那么说明还存其它过期 Entry，直接对这些
77    // Entry 所在位置进行清理。
78    if (slotToExpunge != staleSlot) {
79        cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
80    }
81}