史上最详细之ThreadLocal源码分析

Posted 2021-04-05 小路偶尔爱coding

ThreadLocal源码解读

前言：为更好的理解ThreadLocal内部原理,记录一下源码分析。

Hash相关初始操作

public class ThreadLocal<T> { /** * ThreadLocal实例会被当做Key存放到Thread.threadLocals「ThreadLocalMap」中 * 需要根据ThreadLocal的 nextHashCode 根据0x61c88647 的步长一直递增计算的 */ private final int threadLocalHashCode = nextHashCode();
 /**     * The next hash code to be given out. Updatedatomically. Starts at * zero.     * 下一个要给出的哈希码。原子更新。从零开始  根据0x61c88647 的步一直递增计算 */ private static AtomicInteger nextHashCode = new AtomicInteger();
 /**     * hashCode递增的步长，为什么是这个数？https://zhuanlan.zhhu.com/p/40515974 * 0x61c88647 转化成二进制即为 1640531527 * 均匀分布在2^N数组里 */ private static final int HASH_INCREMENT = 0x61c88647;
 /** * Returns the next hash code. * 原子自增返回 */ private static int nextHashCode() { return nextHashCode.getAndAdd(HASH_INCREMENT); } /** * 可以在定义ThreadLocal时候进行重写，return一个想要的 T 型对象 */ protected T initialValue() { return null; }

ThreadLocalMap内部类

static class ThreadLocalMap {
 /**     * 底层采用Entry[]数组来保存数据。和HashMap不同的是，遇到哈希冲时，Entry并不会转换为链表或红黑树 * 而是采用开放定址法的线性探测来实现 *     * Entry继承自WeakReference，它的Key是一个弱引用，使用的时候需注意，尽可能的去手动执行remove()， * 以免发生内存泄漏。 */ static class Entry extends WeakReference<ThreadLocal<?>> { /** The value associated with this ThreadLocal. */ Object value; Entry(ThreadLocal<?> k, Object v) { super(k); value = v; } }
 /** * 初始化默认大小 */ private static final int INITIAL_CAPACITY = 16;
 /** * The table, resized as necessary. * table.length MUST always be a power of two. */ private Entry[] table;
 /** * The number of entries in the table. * 元素大小 */ private int size = 0;
 /** * The next size value at which to resize. * 扩容阀值 */ private int threshold; // Default to 0
 /** * 初始化ThreadLocalMap实例 */ ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) { // 初始化，默认容量16 table = new Entry[INITIAL_CAPACITY]; // 计算下标，算法：hashCode & (len - 1)，和HashMap一样 int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1); table[i] = new Entry(firstKey, firstValue); size = 1; // 设置扩容阈值「容量的三分之二」 setThreshold(INITIAL_CAPACITY); } // 扩容阈值计算 private void setThreshold(int len) { threshold = len * 2 / 3; }

set()方法源码详细分析

public void set(T value) { // 获取当前Thread对象 Thread t = Thread.currentThread(); // 获取Thread中的ThreadLocals「ThreadLocalMap」    ThreadLocalMap map = getMap(t); // getMap -> return t.threadLocals;  if (map != null)       // 不为null直接set ， <「keythis是ThreadLocal,「value value> map.set(this, value); else // 为null创建并set createMap(t, value);  // 指向方法t.threadLocals = new ThreadLocalMap(this, firstValue); // 给Thread的threadLocals创建Map实例，并添加元素。}
// 1.ThreadLocalMap 为null时候初始化创建如上在内部类中「初始化ThreadLocalMap实例」
// 2.ThreadLocalMap 不为null时候set过程如下

private void set(ThreadLocal<?> key, Object value) {
 // 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.
    // 当前ThreadLocalMap的table数组,可以说初始化ThreadLocalMap例那个16，此处是set说明 // table是已经存在了，且size就是当前table的size Entry[] tab = table; int len = tab.length; // 当前长度 // 计算下标，算法：hashCode & (len - 1)，和HashMap一样 按位于操作 int i = key.threadLocalHashCode & (len-1);
 for (Entry e = tab[i];         // 如果下标元素不是null，有两种情况:1.同一个Key，覆value。2.哈希冲突了。 e != null; // 哈希冲突的解决方式:开放定址法的线性探测。         // 当前下标被占用了，就找next，找到尾巴还没找到就从头开始找。         // 直到找到没有被占用的下标。 e = tab[i = nextIndex(i, len)]) { ThreadLocal<?> k = e.get(); // 同一个Key，覆盖value if (k == key) { e.value = value; return; }        // 下标被占用，但是Key.get()为null。说明ThreadLocal被回了。需要进行替换。 if (k == null) { replaceStaleEntry(key, value, i); return; } } // 添加成功 tab[i] = new Entry(key, value); int sz = ++size; // 1.判断是否可以清理一些槽位。        // 2.  &&符号前    如果清理成功，就无需扩容了，因为已经腾出些位置留给下次使用。 // 3. &&符号前后 如果清理失败，则要判断是否需要扩容「size >= 大于阀值」 if (!cleanSomeSlots(i, sz) && sz >= threshold) // 对元素做rehash操作 rehash();}

// 清理部分槽位,处于性能考虑，不会做所有元素做清理工作，而是采样清理。// 1.如果清理成功，就不用扩容了，因为已经腾出一部分位置了。// n=size，搜索范围较小。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，扩大搜索范围 n = len; removed = true; // 执行清理的核心逻辑 i = expungeStaleEntry(i); }    } while ( (n >>>= 1) != 0);//采样规则: n >>>= 1 (折半)例:100 > 50 > 25 > 12 > 6 > 3 > 1 return removed;}

核心清理逻辑

// 删除过期的元素 「占用下标，但是ThreadLocal实例已经被回收的元素」private int expungeStaleEntry(int staleSlot) { Entry[] tab = table; int len = tab.length;
 // expunge entry at staleSlot // 清理当前Entry tab[staleSlot].value = null; tab[staleSlot] = null; size--;
 // Rehash until we encounter null Entry e; int i; // 继续往后寻找，直到遇到null结束    // 并不是只清理掉当前Entry就结束了，而是往后环形的继续寻找过期的Etry，只要找到了就清理    // 直到遇到 tab[i]==null就结束，清理的过程中还会对元素做一个rhash的操作。 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;
                // Unlike Knuth 6.4 Algorithm R, we must scanuntil                // null because multiple entries could havebeen stale. while (tab[h] != null) h = nextIndex(h, len); tab[h] = e; } } } return i;}

private void rehash() { // 全量清理过期Entry    expungeStaleEntries(); // 清理后，如果size依然超过阈值的四分之三，则要扩容    if (size >= threshold - threshold / 4)        // 扩容操作        resize();}

全量清理过期Entry逻辑

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

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) { // 发现过期元素，会跳过，GC 等待回收 e.value = null; // Help the GC } else { int h = k.threadLocalHashCode & (newLen - 1); // 通过hash计算 把数据放新数组 while (newTab[h] != null) h = nextIndex(h, newLen); newTab[h] = e; count++; } } } // 重新设置阈值 -> threshold = len * 2 / 3; setThreshold(newLen); // 当前长度 size = count; // 引用指向新的table table = newTab;}

get()方法源码详细分析

/** * Returns the value in the current thread's copy of this * thread-local variable.  If the variable has no value forthe * current thread, it is first initialized to the value rturned * 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 ThreadLocalMap map = getMap(t); if (map != null) { // 不为null 通过getEntry，获取Entry中对应value值 ThreadLocalMap.Entry e = map.getEntry(this); if (e != null) { @SuppressWarnings("unchecked") T result = (T)e.value; return result; } }    // 如果为null，则创建Map并设置初始值。其调用的createMap()创建set中的创建方式 return setInitialValue();}

getEntry流程

private Entry getEntry(ThreadLocal<?> key) { // 计算下标 int i = key.threadLocalHashCode & (table.length - 1); Entry e = table[i]; // 对应下标节点不为null，且Key相等，则命中直接返回 if (e != null && e.get() == key) return e; else        // 否则有两种情况:1.Key不存在。2.哈希冲突了，需要向后环形找。 return getEntryAfterMiss(key, i, e);}

getEntryAfterMiss流程

private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) { Entry[] tab = table; int len = tab.length;
 while (e != null) { ThreadLocal<?> k = e.get(); if (k == key)           // 找到了，是哈希冲突 通过nextIndex环形往后一直找到对应的值 return e; if (k == null)           // Key存在，但是过期了，需要清理掉，并且返回null 「上方核心清理逻辑」 expungeStaleEntry(i); else // 向后环形查找 i = nextIndex(i, len); e = tab[i]; } // e==null说明Key不存在，直接返回null return null;}

remove方法源码详细分析

public void remove() { ThreadLocalMap m = getMap(Thread.currentThread()); if (m != null)// 执行清理 m.remove(this);}

/** * 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) { // 这里并没有直接清理，而是将Key的Reference引用清空了， e.clear();            // 然后再调用expungeStaleEntry()清理过期元素。顺便还可以清理后续节点。 expungeStaleEntry(i); // 「核心清理逻辑」 return; } }}// 由于哈希冲突的存在，所以不能定位到节点后直接删除// 需要确认Key是否相等，如果不等需要往后环形查找，直到找到正确的Key。
// 清理也不是简单的直接置空，而是先将Key的引用置空// 然后调用了expungeStaleEntry()「核心清理逻辑」方法清理过期的元素。// 这个过程会顺带清理后续的节点和rehash操作

总结

弱引用问题：

每个线程都有自己的ThreadLocalMap，如果ThreadLocalMap强引用了key 「ThreadLocal」即使执行了ThreadLocal=null，ThreadLocal也无法被回收。

你可以遍历所有线程，将所有线程的ThreadLocalMap的当前ThreadLocal进行remove操作，觉得合适吗？

由于采用了弱引用，只要ThreadLocal实例外部不存在强引用，GC时就能将其回收，ThreadLocalMap在进行一些读写操作时，也会去自发性的做一些过期检查，删除过期的Entry，最大程度的避免了内存泄漏。

内存泄漏：

ThreadLocalMap的弱引用只针对Key，如果ThreadLocal不存在强引用了，GC就会将其回收，但是Value由于存在和Entry的强引用，因此不会被回收，这样就会导致一些永远也无法被访问的Value存在，即发生内存泄漏。

当然，在上面源码分析当中JDK已经有了部分优化，对ThreadLocal进行读写时，几个地方会触发它执行过期检查，删除过期的Entry，避免内存泄漏。

过期清理的触发点：

1.调用set()方法时，采样清理、全量清理，扩容时还会继续检查。2.调用get()方法，没有直接命中，向后环形查找时。3.调用remove()时，除了清理当前Entry，还会向后继续清理。

避免内存泄漏：

使用ThreadLocal时，一般建议将其声明为static final的，避免频繁创建ThreadLocal实例。

尽量避免存储大对象，尽量在访问完成后及时调用remove()删除掉。

总而言之就是一句话，请及时 remove()

关键字：

ThreadLocalMap  set get remove 容量 扩容阀值 环形过期清理 Hash冲突 线性探测 双倍扩容

欢迎关注我的公众号
学习技术 分享生活

▼

长按上图，识别图中二维码即可关注