ThreadLocal内部设计
在java8中ThreadLocal是这样设计的:每个Thread维护一个threadLocalMap,这个Map的key是ThreadLocal本身,value才是真正要存储的Object
具体过程是这样的
- 每个Thread线程内部都有一个Map(ThreadLocalMap)
- Map里面存储ThreadLocal对象(key)和线程的变量副本
- Thread内部的Map是由ThreadLocal维护的,由ThreadLocal负责向Map获取和设置线程的变量值
- 对于不同的线程每次获取副本值时,别的线程并不能获取到当前线程的副本值,形成了副本值的隔离
jdk8中这样设计有两个好处,
- 往往在开发当中ThreadLocal的数量是少于线程数量的,所有每个Map存储的Entry数量变少
- 当Thread销毁的时候,ThreadLocal也会随之销毁,减少内存开销
ThreadLocal源码分析
/** * 设置当前线程对应的ThreadLocal的值 * @param value */ public void set(T value) { // 获取当前线程对象 Thread t = Thread.currentThread(); // 获取此线程对象中维护的ThreadLocalMap对象 ThreadLocal.ThreadLocalMap map = getMap(t); // 判断map是否存在 if (map != null) // 存在则设置此实体entry map.set(this, value); else // 1 当前线程Thread 不存在ThreaLocal对象 // 2 则调用createMap进行ThreadLocalMap对象的初始化 // 3 并将 t(当前线程)和value作为第一个entry存放至ThreadLocalMap中 createMap(t, value); } /** * 返回当前线程中保存的ThreadLocal的值 * 如果当前线程没有此ThreadLocal变量,则他会通过调用 setInitialValue 方法进行初始化, * * @return 如果存在则返回值,如果不存则创建并返回初始值null */ public T get() { // 获取当前线程 Thread t = Thread.currentThread(); // 获取此线程对象中的ThreadLocalMap对象 ThreadLocal.ThreadLocalMap map = getMap(t); if (map != null) { // 以当前的threadLocal为key,调取getEntry获取对应的存储实体e ThreadLocal.ThreadLocalMap.Entry e = map.getEntry(this); if (e != null) { @SuppressWarnings("unchecked") T result = (T)e.value; return result; } } // 初始化 有两种情况执行当前代码 // 1 map不存在,标识此线程没有维护的ThreadLocalMap对象 // 2 map存在,但是没有与当前ThreadLocal关联的entry return setInitialValue(); } /** * 删除当前线程中保存的ThreadLocal对应的实体Entery */ public void remove() { // 获取当前线程对象中维护的ThreadLocalMap对象 ThreadLocal.ThreadLocalMap m = getMap(Thread.currentThread()); // 如果此map存在 if (m != null) // 则调用map.remove // 以当前ThreadLocal为key删除对应的实体entry m.remove(this); }
ThreadLocalMap源码分析
ThreadLocalMap是ThreadLocal的内部类,没有实现Map接口,用独立的方式实现了Map的功能,其内部的Entry也是独立实现
成员变量
/** * 初始容量 -- 必须是2的整次幂 */ private static final int INITIAL_CAPACITY = 16; /** * 存放数据的table, * 通用数组长必须是2的整次幂 */ private Entry[] table; /** * 数组里entrys的个数,可以用于判断table当前使用量是否超过阈值 */ private int size = 0; /** * 进行扩容的阈值,表使用量大于它的时候进行扩容 */ private int threshold; // Default to 0
存储结构 Entry
/** * Entry继承weakReference,并且用ThreadLocal作为key * 如果key为null(entry.get()==null),意味着key不在被引用,因此这时候entry也可以从table中清除 */ static class Entry extends WeakReference<ThreadLocal<?>> { /** The value associated with this ThreadLocal. */ Object value; Entry(ThreadLocal<?> k, Object v) { super(k); value = v; } }
在ThreadLocalMap中,也是用Entry来保存K-V数据结构的,不过entry中的key只能是threadLocal对象,这点在构造方法中已经限定死了,另外Entry继承weakReference,也就是key(ThreadLocal)是弱引用,其目的是将ThreadLocal对象的声明周期和线程声明周期解绑
弱引用和内存泄漏
强引用: 就是我们最常见的普通对象引用,只要还有强引用指向一个对象,就能带边对象还活着,垃圾回收器就不会回收这种对象
弱引用: 垃圾回收器一旦发现了只具有弱引用的对象,不管当前内存空间是否足够,都会回收它的内存,但是弱引用的对象,被其他强引用对象所引用,依然不会被回收
1在业务代码中,使用完threadLocal,threadLocal 的引用被回收
2 由于ThreadLocalMap只持有ThreadLocal的弱引用,没有任何强引用执行啊threadlocal实例,所以threadlocal就可以被gc回收,此时entry中的key=null
3 但是在没有手动删除这个entry,以及currentThread依然在运行的前提下(线程池场景),也存在有强引用链 threadRef -> currentThread -> threadLocalMap -> entry -> value ,value不会被回收,而这块value永远不会被访问到了,导致value内存泄漏
也就是说threadLocalMap中的key使用了弱引用,也有可能内存泄漏
entry为什么使用弱引用?
ThreadLocalMap中的set/getEntry方法中,会对entrys中所有key(也就是ThreadLocal为null)进行判断,如果为null的话,那么就会对value置为null,这就意味着,使用完ThreadLocal,currentThread依然运行的前提下,就算忘记调用remove方法,弱引用比强引用可以多一层保障:弱引用的ThreadLocal会被回收,对应的value在下一次ThreadLocalMap调用set get remove中的任一方法的时候会被清除,从而避免内存泄漏
hash冲突的解决
ThreadLocalMap的构造方法
/** * * @param firstKey 本ThreadLocal实例 * @param firstValue 要保存的线程本地变量 */ ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) { // 初始化table table = new ThreadLocal.ThreadLocalMap.Entry[INITIAL_CAPACITY]; // 计算索引(重点代码) int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1); // 设置值 table[i] = new ThreadLocal.ThreadLocalMap.Entry(firstKey, firstValue); size = 1; // 设置阈值 setThreshold(INITIAL_CAPACITY); }
构造一个长度为16的entry数组,然后计算出firstKey对应的索引,然后存储到table中,并设置size和threshold
重点分析 int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
关于 firstKey.threadLocalHashCode :
private final int threadLocalHashCode = nextHashCode(); // 原子Integer类,用于并发场景下做加减操作,保障线程的安全 private static AtomicInteger nextHashCode = new AtomicInteger(); // 特殊的hash值 private static final int HASH_INCREMENT = 0x61c88647; private static int nextHashCode() { return nextHashCode.getAndAdd(HASH_INCREMENT); }
这里定义了一个 AtomicInteger 类型,每次获取当前值并加上 HASH_INCREMENT , HASH_INCREMENT 的值跟斐波那契数列(黄金分割数列)有关,其主要目的是为了让hash值能够更均匀的分布在2的n次方的数组里,也就是entry[] table中,这样做可以避免hash冲突
关于 & (INITIAL_CAPACITY - 1):
计算hash的时候采用hashCode&(size -1) 的算法,这相当于取模运算hashCode % (size-1) 的一个更高效的实现,正因为这种算法,我们要求size必须是2的整次幂,这也能保证在索引不越界的前提下,是的hash发生的冲突次数减小
ThreadLocalMap中的set方法
private void set(ThreadLocal<?> key, Object value) { ThreadLocal.Entry[] tab = table; int len = tab.length; // 计算索引 int i = key.threadLocalHashCode & (len-1); /** * 使用线性探测发查找元素(重点代码) */ for (ThreadLocal.ThreadLocalMap.Entry e = tab[i]; e != null; e = tab[i = nextIndex(i, len)]) { ThreadLocal<?> k = e.get(); // ThreadLocal 对应的 key 存在,直接覆盖之前的值 if (k == key) { e.value = value; return; } // key为null,但是值不为null,说明之前的ThreadLocal对象已经被回收了 // 当前数组中的Entry是一个陈旧的元素 if (k == null) { // 用新的元素替换陈旧的元素,这个方法进行了不少垃圾清理动作,防止内存泄漏 replaceStaleEntry(key, value, i); return; } } // ThreadLocal对应的key不存在并且没有找到陈旧的元素,则在空元素的位置创建一个新的Entry tab[i] = new ThreadLocal.ThreadLocalMap.Entry(key, value); int sz = ++size; /** * cleanSomeSlots 用于清除那些 e.get==null(没有引用了,说明可以被回收) 的元素 * 这种数据的key关联的对象已经被回收,所以这个entry可以被置为null * 如果没有清除任何entry,并且使用量到达了负责因子所定义的长度,那么进行 * rehash 这个方法首先会回收一次 entrys,如果回收完之后满足 size(当前数量) >= threshold(阈值) - threshold(阈值) / 4 , * 则进行扩容,扩容为当前容量的2倍 16 *2 */ if (!cleanSomeSlots(i, sz) && sz >= threshold) rehash(); } // 获取环形数组的下一个索引 private static int nextIndex(int i, int len) { return ((i + 1 < len) ? i + 1 : 0); }
代码执行流程:
1 首先根据key计算出索引i,然后查找i位置上的entry
2 若entry存在并且key等于传入的key,那么这个时候直接给这个entry赋新的value值
3 若entry存在并且key为null,则调用replaceStaleEntry来更换这个key为空的Entry
4 不断循环检测,知道遇到为null的地方,这个时候如果还没有在循环中return,那么就在null的位置新建一个entry,并且插入,同事size增加1
最后调用cleanSomeSlots,清理key为null的Entry,最后返回是否清理了Entry,接下来再判断sz是否达到rehash的条件,达到的话就进行一次rehash函数,执行一次全表扫描清理,如果清理完之后,需要扩容,则进行扩容
ThreadLocalMap使用线性探测法来解决hash冲突:
该方法一次探测下一个地址,直到有空的地址后插入,若整个空间都找不到空余的地址,则产生溢出.
举个例子,假设当前的table长度为16,也就是说如果计算出来的key的hash值为14,如果table[14]上已经有值,并且其key与当前key不一致,那么就发生hash冲突,这个时候将14加1得到15,去table[15]进行判断,这个时候如果还是冲突,会回到索引0,去table[0],以此类推
按照上面的描述,可以把Entry[] table看成一个环形数组
以下是源码核心方法的翻译
package java.lang; import java.lang.ref.WeakReference; import java.util.Objects; import java.util.concurrent.atomic.AtomicInteger; import java.util.function.Supplier; /** * 此类提供线程局部变量。 * 这些变量与其正常对应变量的不同之处在于，访问一个变量的每个线程(通过其{@code get}或{@code set}方法)都有自己的独立初始化的变量副本。 * {@code ThreadLocal}实例通常是希望将状态与线程(例如，用户ID或事务ID)相关联的类中的私有静态字段。 * 例如，下面的类生成每个线程本地的唯一标识符。 * 线程的id在它第一次调用{@code ThreadId.get()}时被分配，并且在随后的调用中保持不变。 * * <pre> * import java.util.concurrent.atomic.AtomicInteger; * * public class ThreadId { * //包含要分配的下一个线程ID的原子整数 * private static final AtomicInteger nextId = new AtomicInteger(0); * * // 包含每个线程ID的线程局部变量 * private static final ThreadLocal<Integer> threadId = * new ThreadLocal<Integer>() { * @Override * protected Integer initialValue() { * return nextId.getAndIncrement(); * } * }; * * // 返回当前线程的唯一ID，如有必要将其分配 * public static int get() { * return threadId.get(); * } * } * </pre> * 只要线程是活动的，并且{@code ThreadLocal}实例是可访问的，每个线程都持有对其线程本地变量副本的隐式引用； * 线程执行完毕(销毁)后，它的所有线程本地实例副本都会被垃圾收集器回收(除非存在对这些副本的其他引用)。 * * @param <T> * @author Josh Bloch and Doug Lea * @since 1.2 */ public class ThreadLocal<T> { /** * ThreadLocals依赖于附加到每个线程的每个线程的线性探测散列映射(Thread.threadLocals和InheritableThreadLocals)。 * ThreadLocal对象充当键，通过threadLocalHashCode进行搜索。 * 这是一个自定义散列代码(仅在ThreadLocalMaps中有用)，它可以在相同线程使用连续构造的ThreadLocal的常见情况下消除冲突，同时在不太常见的情况下保持良好的行为 * <p> * 解读: 这里定义了一个 AtomicInteger 类型,每次获取当前值并加上 HASH_INCREMENT , * HASH_INCREMENT 的值跟斐波那契数列(黄金分割数列)有关, * 其主要目的是为了让hash值能够更均匀的分布在2的n次方的数组里,也就是entry[] table中, * 这样做可以避免hash冲突 */ private final int threadLocalHashCode = nextHashCode(); /** * 用于计算哈希码。自动更新。从零开始 */ private static AtomicInteger nextHashCode = new AtomicInteger(); /** * HASH_INCREMENT 的值跟斐波那契数列(黄金分割数列)有关,其主要目的是为了让hash值能够更均匀的分布在2的n次方的数组里 */ private static final int HASH_INCREMENT = 0x61c88647; /** * 返回计算好的hash值 */ private static int nextHashCode() { return nextHashCode.getAndAdd(HASH_INCREMENT); } /** * 返回此线程局部变量的当前线程的“初始值”。 * 此方法将在线程第一次使用{@link#get}方法访问变量时调用. * 除非该线程先前调用了{@link#set}方法,在这种情况下，不会为线程调用{@code InitialValue}方法。 * 通常情况下，每个线程最多调用此方法一次，但如果随后调用{@link#Remove}，然后调用{@link#get}，则可能会再次调用此方法。 * * <p>该实现只返回{@code NULL}； * 如果程序员希望线程局部变量具有不同于{@code NULL}的初始值， * 必须将{@code ThreadLocal}派生为子类，并重写此方法。 * 通常，将使用匿名内部类。 * * @return 此本地线程的初始值 */ protected T initialValue() { return null; } /** * 创建线程局部变量。该变量的初始值是通过调用{@code Supplier}上的{@code get}方法来确定的。 * * @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); } /** * 空参构造 * * @see #withInitial(java.util.function.Supplier) */ public ThreadLocal() { } /** * 返回此线程局部变量的当前线程副本中的值。 * 如果变量没有当前线程的值，它首先被初始化为调用{@link#InitialValue}方法返回的值。 * * @return the current thread's value of this thread-local */ public T get() { // 获取当前线程 Thread t = Thread.currentThread(); // 获取当前线程中的ThreadLocalMap 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; } } // 不存在则初始化一个key为当前ThreadLocal value为null的Entry // 1 map不存在,标识此线程没有维护的ThreadLocalMap对象 // 2 map存在,但是没有与当前ThreadLocal关联的entry return setInitialValue(); } /** * Set()的变体，用于建立InitialValue。 * 在用户重写set()方法的情况下使用，而不是set() * * @return the initial value */ 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); return value; } /** * 将此线程局部变量的当前线程副本设置为指定值。 * 大多数子类将不需要重写此方法， * 仅依靠{@link#InitialValue}方法来设置线程局部变量的值。 * * @param value 要存储在此本地线程的当前线程副本中的值。 */ public void set(T value) { // 获取当前线程 Thread t = Thread.currentThread(); // 获取线上的 ThreadLocalMap ThreadLocalMap map = getMap(t); if (map != null) map.set(this, value); else // 1 当前线程Thread 不存在ThreaLocal对象 // 2 则调用createMap进行ThreadLocalMap对象的初始化 // 3 并将 t(当前线程)和value作为第一个entry存放至ThreadLocalMap中 createMap(t, value); } /** * 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中重写。 * * @param t the current thread * @return the map */ ThreadLocalMap getMap(Thread t) { return t.threadLocals; } /** * 创建与ThreadLocal关联的映射。 * 在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); } /** * 用于创建继承的线程局部变量映射的工厂方法。 * 设计为只能从线程构造函数调用。 * * @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); } /** * 方法Child Value在子类InheritableThreadLocal中可见地定义， * 但是在这里内部定义是为了提供createInheritedMap工厂方法，而不需要在InheritableThreadLocal中子类化映射类。 * 这种技术比在方法中嵌入instanceof测试的选择更可取。 */ T childValue(T parentValue) { throw new UnsupportedOperationException(); } /** * ThreadLocal的扩展，从指定的{@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是一个定制的散列映射，仅适用于维护线程局部值。 * 不会将任何操作导出到ThreadLocal类之外。 * 该类是包私有的，以允许在类Thread中声明字段。 * 为了帮助处理非常大且寿命很长的使用， * 哈希表条目使用WeakReference作为键。 * 但是，由于不使用引用队列，因此只有在表的空间开始耗尽时，才能保证删除过时的条目 */ static class ThreadLocalMap { /** * 该散列映射中的条目扩展了WeakReference， * 使用其主ref字段作为键(它始终是ThreadLocal对象)。 * 注意，空键(即Entry_Get()==NULL)意味着该键不再被引用， * 因此可以从表中删除该条目。 * 在下面的代码中，这样的条目被称为“陈旧条目”。 */ static class Entry extends WeakReference<ThreadLocal<?>> { /** * 与此ThreadLocal关联的值 */ Object value; Entry(ThreadLocal<?> k, Object v) { super(k); value = v; } } /** * 初始容量 -- 必须是2的整次幂 */ private static final int INITIAL_CAPACITY = 16; /** * 存放数据的table, * 通用数组长必须是2的整次幂 */ private Entry[] table; /** * 数组里entrys的个数,可以用于判断table当前使用量是否超过阈值 */ private int size = 0; /** * 进行扩容的阈值,表使用量大于它的时候进行扩容 */ private int threshold; // Default to 0 /** * 将调整大小阈值设置为在最坏情况下保持2/3的负载率 */ private void setThreshold(int len) { threshold = len * 2 / 3; } /** * 获取环形数组的下一个索引 */ private static int nextIndex(int i, int len) { return ((i + 1 < len) ? i + 1 : 0); } /** * 获取环形数组的上一个索引 */ private static int prevIndex(int i, int len) { return ((i - 1 >= 0) ? i - 1 : len - 1); } /** * 构建一个最初包含(FirstKey，FirstValue)的新地图。 * ThreadLocalMaps是懒惰地构建的， * 因此，当我们至少有一个条目要放入其中时，我们才会创建一个条目。 */ ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) { // 初始容量16 table = new Entry[INITIAL_CAPACITY]; // 通过hash获取索引 int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1); table[i] = new Entry(firstKey, firstValue); size = 1; // 设置扩容阈值 setThreshold(INITIAL_CAPACITY); } /** * 构建包含所有可继承的ThreadLocal的新地图。 * 从给定的父地图。仅由createInheritedMap调用。 * * @param parentMap the map associated with parent thread. */ private ThreadLocalMap(ThreadLocalMap parentMap) { Entry[] parentTable = parentMap.table; int len = parentTable.length; setThreshold(len); table = new Entry[len]; for (int j = 0; j < len; j++) { Entry e = parentTable[j]; if (e != null) { @SuppressWarnings("unchecked") ThreadLocal<Object> key = (ThreadLocal<Object>) e.get(); if (key != null) { Object value = key.childValue(e.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关联的条目。 * 此方法本身只处理快速路径：直接命中现有键。否则它会转发到GetEntryAfterMisse。 * 这是为了最大限度地提高直接命中的性能， * 这在一定程度上是通过使这种方法易于内联来实现的。 * * @param key the thread local object * @return 与键关联的entry，如果没有，则返回NULL */ 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); } /** * 在其直接哈希槽中找不到key时 则调用此方法 * * @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; while (e != null) { /* e.get()方法: 返回此引用对象的引用。 如果该对象的引用已被，程序或垃圾收集器清除.则返回<code>NULL</code>。 */ ThreadLocal<?> k = e.get(); if (k == key) return e; if (k == null) // 这里的意思是 如果entry不为null,但是已经没有对象引用该entry了(上一次使用ThreadLocal没有主动remove),使用过该entry的对象已经被回收了 // 说明这个entry可以被回收,则执行 expungeStaleEntry 方法,将该索引上的数据进行清理 expungeStaleEntry(i); else i = nextIndex(i, len); e = tab[i]; } return null; } /** * 设置与Key关联的值。 * * @param key the thread local object * @param value the value to be set */ 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(); // ThreadLocal 对应的 key 存在,直接覆盖之前的值 if (k == key) { e.value = value; return; } // key为null,但是值不为null,说明之前的ThreadLocal对象已经被回收了 // 当前数组中的Entry是一个陈旧的元素 if (k == null) { // 用新的元素替换陈旧的元素,这个方法进行了不少垃圾清理动作,防止内存泄漏 replaceStaleEntry(key, value, i); return; } } // ThreadLocal对应的key不存在并且没有找到陈旧的元素,则在空元素的位置创建一个新的Entry tab[i] = new Entry(key, value); int sz = ++size; /* * cleanSomeSlots 用于清除那些 e.get==null(没有引用了,说明可以被回收) 的元素 * 这种数据的key关联的对象已经被回收,所以这个entry可以被置为null * 如果没有清除任何entry,并且使用量到达了负责因子所定义的长度,那么进行 * rehash 这个方法首先会回收一次 entrys,如果回收完之后满足 size(当前数量) >= threshold(阈值) - threshold(阈值) / 4 , * 则进行扩容,扩容为当前容量的2倍 16 *2 */ if (!cleanSomeSlots(i, sz) && sz >= threshold) rehash(); } /** * 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) { // 清空entry的引用 e.clear(); // 垃圾清理操作 expungeStaleEntry(i); return; } } } /** * 将集合操作期间遇到的过时项 替换为指定键的项。 * 在Value参数中传递的值存储在条目中， * 是否已存在指定键的条目。 * <p>。 * 作为副作用，此方法将清除包含过时条目的“run”中的所有过时条目。 * (运行是两个空槽之间的条目序列。) * * @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; //重新检查当前运行中是否有过时的条目。 // 清除整个table，以避免 // 由于垃圾回收器释放 // 大量的引用（即，每当收集器运行时）而导致的连续重新哈希处理。 int slotToExpunge = staleSlot; for (int i = prevIndex(staleSlot, len); (e = tab[i]) != null; i = prevIndex(i, len)) if (e.get() == null) slotToExpunge = i; // 查找运行的键或尾随空槽，以先到者为准 for (int i = nextIndex(staleSlot, len); (e = tab[i]) != null; i = nextIndex(i, len)) { ThreadLocal<?> k = e.get(); //如果找到密钥，则需要将其 // 与旧条目交换以维护哈希表顺序。 // 然后，可以将新失效的插槽或它上面遇到的任何其他失效插槽发送到expungeStaleEntry // ，以删除或重新哈希运行中的所有其他条目。 if (k == key) { e.value = value; tab[i] = tab[staleSlot]; tab[staleSlot] = e; // 如果先前的陈旧条目存在，则开始清除 if (slotToExpunge == staleSlot) slotToExpunge = i; cleanSomeSlots(expungeStaleEntry(slotToExpunge), len); return; } //如果我们在向后扫描中未找到陈旧条目，则 // 在扫描密钥时看到的第一个陈旧条目是否为 // 运行中仍然存在的第一个。 if (k == null && slotToExpunge == staleSlot) slotToExpunge = i; } // 如果找不到key，将新条目放入陈旧的插槽中 tab[staleSlot].value = null; tab[staleSlot] = new Entry(key, value); // 如果运行中还有其他任何陈旧条目，则将它们清除 if (slotToExpunge != staleSlot) cleanSomeSlots(expungeStaleEntry(slotToExpunge), len); } /** * 通过重新散列位于StalleSlot和下一个空槽之间的任何可能冲突的条目来删除过时的条目。 * 这还会删除尾随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; //清除value tab[staleSlot].value = null; tab[staleSlot] = null; size--; /* 使用线性探测发查找元素(重点代码) 循环清除entrys中引用为null的元素 */ 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; //与Knuth 6.4算法R不同，我们必须扫描直到//为null，因为可能已经过时了多个条目。 while (tab[h] != null) h = nextIndex(h, len); tab[h] = e; } } } return i; } /** * 启发式地扫描一些单元格，寻找过时的条目。 * 这在添加新元素时被调用， * 或者另一个陈旧的已经被删除了。 * 它执行对数次扫描， * 作为不扫描(快速但保留垃圾)和与元素数量成比例的扫描数量之间的平衡， * 这将查找所有垃圾，但会导致某些插入花费O(N)时间. * * @param i a position known NOT to hold a stale entry. The * scan starts at the element after i. * @param n 扫描控制：扫描{@code log2（n）}个单元， * *除非找到陈旧的条目，否则将扫描{{code log2（table.length）-1}}个其他单元。 * *从插入处调用时，此参数是元素的数量，但是从replaceStaleEntry中调用时，它是表的长度。 * （注意：通过对n加权而不是仅使用直接对数n可以将所有这些更改为*或多或少具有侵略性。但是此版本简单，快速，并且*似乎运行良好。） * @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 = 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大小。首先扫描整个表，删除陈旧的条目。如果还不够缩小表元素个数，则将表的大小加倍。 */ private void rehash() { expungeStaleEntries(); // Use lower threshold for doubling to avoid hysteresis if (size >= threshold - threshold / 4) resize(); } /** * 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 (int j = 0; j < oldLen; ++j) { Entry e = oldTab[j]; if (e != null) { ThreadLocal<?> k = e.get(); if (k == null) { e.value = null; // Help the GC } else { 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) expungeStaleEntry(j); } } } }