【ThreadLocal】ThreadLocal的实现机制和原理
1 前言
这节我们看下 ThreadLocal ，这个东西大家应该不陌生，经常在一些同步优化中会使用到它。很多地方叫线程本地变量，ThreadLocal为变量在每个线程中都创建了一个副本，那么每个线程可以访问自己内部的副本变量。也就是对于同一个ThreadLocal，每个线程通过get、set、remove接口操作只会影响自身线程的数据，不会干扰其他线程中的数据。常见的比如我们的登录信息是不是用到了，AOP里的 AOPContext等，那么这节我们就来看看它的实现机制。
2 类图
说到 ThreadLocal ，涉及的相关类我们先简单介绍下：
- ThreadLocal 核心类，本地线程类，他里边有两个子类：SuppliedThreadLocal这个主要是传的表达式相当于延迟初始化，当调用get的时候才会获取值；ThreadLocalMap这个就是用来存放数据管理数据的，会依附在 Thread 里；
- Thread 线程类 内部拥有ThreadLocalMap变量，有两个，threadLocals 负责正常存放某个本地线程变量，inheritableThreadLocals负责父子线程传递的；
- InheritableThreadLocal 用于父子线程的传递
我们看下类图：
3 源码分析
3.1 测试代码
public class TestThreadLocal { // Person类 static class Person { private String name; Person(String name) { this.name = name; } @Override public String toString() { return "Person{" + "name='" + name + '\'' + '}'; } } public static void main(String[] args) { Person person = new Person("狗子"); ThreadLocal<Person> personThreadLocal = new ThreadLocal<>(); personThreadLocal.set(person); System.out.println(personThreadLocal.get()); } }
可以看到我们测试的代码，创建 ThreadLocal 对象，设置值以及获取，那么接下来我们就来看看 set、get方法。
3.2 set 方法
// TheradLocal public void set(T value) { // 获取当前线程 Thread t = Thread.currentThread(); // 获取当前线程中的 map 集合 ThreadLocalMap map = getMap(t); if (map != null) /** * 如果 map 不为空，就设置值 * 可以看到 key 就是我们的 ThreadLocal本身 说明什么？ * 也就是说我们的每个线程中只会存放一个 ThreadLocal对象对应的值 */ map.set(this, value); else /** * map 为空的话 就要创建并赋予 value 初值 */ createMap(t, value); }
// 其实就是 Thread 中的 threadLocals 变量 ThreadLocalMap getMap(Thread t) { return t.threadLocals; }
// Therad public class Thread implements Runnable { /* ThreadLocal values pertaining to this thread. This map is maintained * by the ThreadLocal class. */ ThreadLocal.ThreadLocalMap threadLocals = null; /* * InheritableThreadLocal values pertaining to this thread. This map is * maintained by the InheritableThreadLocal class. */ ThreadLocal.ThreadLocalMap inheritableThreadLocals = null; }
可以看到我们的 set 方法，首先会获取当前线程的 threadLocals，如果为空的话就会创建并赋予初值，不为空的话就会把当前值设置进去，那我们先看一下 createMap 方法看看是如何初始化并赋值的。
3.2.1 createMap 方法
// ThreadLocal void createMap(Thread t, T firstValue) { // 就是创建 ThreadLocalMap 对象，并赋值给线程 t t.threadLocals = new ThreadLocalMap(this, firstValue); }
那我们继续看下 ThreaLocalMap 的实例化：
// ThreadLocalMap ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) { /** * 实例化 table 数组,初始大小为：16 * private static final int INITIAL_CAPACITY = 16; */ table = new Entry[INITIAL_CAPACITY]; /** * 就是根据 ThreadLocal的哈希值和数组的长度取余 * 那你有没有疑问 取余的话，会不会不同的ThreadLocal取余一样不就冲突了？ * 其实 threadLocalHashCode 是递增的，这个你们可以看下我就不在这里看了哈，源码就在上边 用了atomic的增长的 */ int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1); // 设置值 key->我们的ThreadLocal对象 value->就是我们要存放的值 table[i] = new Entry(firstKey, firstValue); // 因为创建并放置了一个键值对所以长度 1 size = 1; // 扩容标志 也就是到达三分之二的时候要进行重新计算扩容 setThreshold(INITIAL_CAPACITY); }
整体上就是实例化我们的ThreaLocalMap ，里边实际上就是有一个 Entry数组来维护，初始化长度为 16，扩容标志是三分之二的水平线。那我们再来简单看下我们的Entry：
// ThreadLocalMap的内部类 // 可以看到我们的 Entry 是继承的弱引用，也就是线程中的 ThreadLocalMap 不会影响 ThreadLocal的回收 static class Entry extends WeakReference<ThreadLocal<?>> { /** The value associated with this ThreadLocal. */ // 我们存放的值 Object value; // k 就是我们的 ThreadLocal对象，弱引用 v就是我们要存放的值 Entry(ThreadLocal<?> k, Object v) { super(k); value = v; } }
可以看到 ThreaLocalMap 弱引用于我们的 ThreadLocal 对象，也就是线程中的 ThreaLocalMap 不会影响我 ThreadLocal 对象的回收。
3.2.2 ThreaLocalMap 中的 set 方法
我们继续看下当线程中的 ThreadLocalMap不为空的话，是如何存放的，看之前首先我们猜猜应该有哪些，我们看到实例化的时候有扩容标志，那么是不是会在 set 的时候来进行扩容的判断呢？是不是我们来看看：
/** * @param key 我们的 ThreadLocal 对象 * @param value 就是我们要存放的值 */ private void set(ThreadLocal<?> key, Object value) { // 我们的 Entry 数组 Entry[] tab = table; // 数组的长度 int len = tab.length; // 取余，判断当前 ThreadLocal 应该存放的索引位置 int i = key.threadLocalHashCode & (len-1); /** * 获取索引下的 Entry 键值对 这里为什么用循环呢？ * threadLocalHashCode 递增的值是 nextHashCode.getAndAdd(HASH_INCREMENT) 0x61c88647 * 并不是按1增长的 所以可能还是会冲突吧 * 所以冲突了就会加1 nextIndex => ((i + 1 < len) ? i + 1 : 0) * 循环的作用： * 1、处理索引冲突 * 2、处理脏的ThreadLocal */ for (Entry e = tab[i]; e != null; e = tab[i = nextIndex(i, len)]) { // 获取到我们的 ThreadLocal 对象 ThreadLocal<?> k = e.get(); // 当发现对应的 ThreadLocal 已经存在某个值，则进行替换并返回 if (k == key) { e.value = value; return; } // 因为 ThreadLocal 是弱引用的， // 那么当 ThreadLocal 被回收时，这里就会为空 // 那么说明我们当前 Entry中的ThreadLocal是脏的了，进行脏处理 if (k == null) { replaceStaleEntry(key, value, i); return; } } // 索引位置的 Entry为空，那么创建 Entry 并设置 value tab[i] = new Entry(key, value); // 长度++ int sz = ++size; /** * cleanSomeSlots 清理脏的 ThreadLocal 发现好严谨奥 * 返回为true 说明有脏的 ThreadLocal * 为false的情况下，并且大小到达了我们的增长标志进行重新hash并扩容 */ if (!cleanSomeSlots(i, sz) && sz >= threshold) rehash(); }
可以看到里边除了常规的替换值设置值，有两个很重要的操作就是清理脏 ThreadLocal - replaceStaleEntry 以及扩容- reHash 判断，其实 cleanSomeSlots 也是清理脏 ThreadLocal，调用的 expungeStaleEntry，我们先来看下 cleanSomeSlots ：
3.2.2.1 cleanSomeSlots
// ThreadLocalMap private boolean cleanSomeSlots(int i, int n) { // 有效清理标志 boolean removed = false; // 我们的 Entry 数组 Entry[] tab = table; // 数组长度 int len = tab.length; do { // 下一个索引 i = nextIndex(i, len); // 获取索引位置的 Entry Entry e = tab[i]; // 判断当前的 Entry 的 ThreadLocal 是否为空 if (e != null && e.get() == null) { // TheradLocal为空 说明是脏的 n = len; // 更新有效清理标志 removed = true; // 清理脏 TheradLocal i = expungeStaleEntry(i); } // 无符号右移 相当于除以2 相当于折半判断并不是全都遍历一遍 } while ( (n >>>= 1) != 0); return removed; }
那我们继续跟进去看下 expungeStaleEntry，是如何清理的：
3.2.2.2 expungeStaleEntry
// ThreadLocalMap // staleSlot 脏ThreadLocal索引 private int expungeStaleEntry(int staleSlot) { // 我们的 Entry 数组 Entry[] tab = table; // 数组的长度 int len = tab.length; // expunge entry at staleSlot // 因为我们的 table 是强引用 value的 这里先把 value的强引用释放 tab[staleSlot].value = null; // 把自身的占位释放 tab[staleSlot] = null; // 长度-- size--; // Rehash until we encounter null Entry e; int i; // 遍历下一个索引位置的 Entry 是否为空 for (i = nextIndex(staleSlot, len); (e = tab[i]) != null; i = nextIndex(i, len)) { // 不为空的话判断 ThreadLocal 是否是脏的 ThreadLocal<?> k = e.get(); // 是脏的话 释放引用 长度-- if (k == null) { e.value = null; tab[i] = null; size--; } else { // ThreadLocal 不脏的情况下 因为前边释放了一个位置 这里再根据长度取余 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; } /** * 我在想为什么要这么做呢？ 为什么还要遍历其它的不为空呃 给他们重新变换位置呢？ * 是为了收缩？还是就是单纯的要释放其它脏的ThreadLocal呢 */ } } return i; }
释放的主要操作就是 tab[i].value = null 释放强引用，并把 tab[i] = null, 其实释放就完事了，但是它还会接着遍历判断下一个索引位置的 Entry 是否也是脏的，是的话也会继续清理，不是的话会调整新位置，直到索引位置的 Entry 是空的话，结束循环完事。这么做的道理可能就是更好的去为 GC做准备释放一些无效的引用，防止内存泄漏嘛。
3.2.2.3 replaceStaleEntry
/** * ThreadLocalMap * @param key 脏的ThreadLocal * @param value 要存放的值 * @param staleSlot 脏索引 */ private void replaceStaleEntry(ThreadLocal<?> key, Object value, int staleSlot) { // 我们的数组 Entry[] tab = table; // 数组的长度 int len = tab.length; Entry e; // Back up to check for prior stale entry in current run. // We clean out whole runs at a time to avoid continual // incremental rehashing due to garbage collector freeing // up refs in bunches (i.e., whenever the collector runs). // slotToExpunge 要去释放的索引位置 int slotToExpunge = staleSlot; // 往前找一个Entry不空的 for (int i = prevIndex(staleSlot, len); (e = tab[i]) != null; i = prevIndex(i, len)) // 发现也是脏的 if (e.get() == null) // 更新要释放的索引位置 slotToExpunge = i; // Find either the key or trailing null slot of run, whichever // occurs first // 又往后找一个 Entry不为空的 for (int i = nextIndex(staleSlot, len); (e = tab[i]) != null; i = nextIndex(i, len)) { // 获取当前不为空的 Entry 的 ThreadLocal ThreadLocal<?> k = e.get(); // If we find key, then we need to swap it // with the stale entry to maintain hash table order. // The newly stale slot, or any other stale slot // encountered above it, can then be sent to expungeStaleEn // to remove or rehash all of the other entries in run. // 发现就是我们参数里的脏ThreadLocal if (k == key) { e.value = value; tab[i] = tab[staleSlot]; tab[staleSlot] = e; // Start expunge at preceding stale entry if it exists if (slotToExpunge == staleSlot) slotToExpunge = i; cleanSomeSlots(expungeStaleEntry(slotToExpunge), len); return; } // If we didn't find stale entry on backward scan, the // first stale entry seen while scanning for key is the // first still present in the run. if (k == null && slotToExpunge == staleSlot) slotToExpunge = i; } // If key not found, put new entry in stale slot tab[staleSlot].value = null; tab[staleSlot] = new Entry(key, value); // If there are any other stale entries in run, expunge them if (slotToExpunge != staleSlot) cleanSomeSlots(expungeStaleEntry(slotToExpunge), len); }
replaceStaleEntry 这个方法说实话有点邪门，没怎么看懂，它这是先往前找一找脏ThreadLocal，然后又往后遍历，我搜了搜别人的理解，也是众说纷纭，暂时保留，总之我们知道这个也是清理脏ThreadLocal的。那我们看见有三个方法来清理脏ThreadLocal的我们看下三者的区别：
- expungeStaleEntry 这个肯定是会清理掉至少一个的，返回值返回的是下一个 空Entry的索引位置；
- replaceStaleEntry 这个方法从我的理解上我觉得时空清理至少一个的；
- cleanSomeSlots 这个是会尝试去清理脏ThreadLocal，有可能没清一个，有可能清了。
set 方法除了清理还有一项重要的是判断是否需要扩容，我们来看下：
3.2.2.4 reHash
// ThreadLocalMap private void rehash() { // 还是会调用 expungeStaleEntry 进行清理脏ThreadLocal expungeStaleEntries(); // Use lower threshold for doubling to avoid hysteresis // 判断是否达到 四分之三 超过了就重新扩容 if (size >= threshold - threshold / 4) resize(); }
// ThreadLocalMap private void resize() { // 我们的数组 Entry[] oldTab = table; // 数组的长度 int oldLen = oldTab.length; // 新数组的长度，可以看到是2倍扩容 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就被丢弃了 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; }
其实我们默认的扩容水平线是：threshold = len * 2 / 3，也就是到达三分之二的时候会进入 reHash 方法，而 reHash会进行脏ThreadLocal的清理，清理后发现长度达到了 四分之三的话，就会扩容，扩容后的长度是原长度的2倍。
3.3 get 方法
看完 set 的方法，我们再来看下 get 的方法：
// ThreadLocal public T get() { // 当前线程 Thread t = Thread.currentThread(); // 当前线程中的 ThreadLocalMap ThreadLocalMap map = getMap(t); // 不为空的话，就从 ThreadLocalMap 取 if (map != null) { ThreadLocalMap.Entry e = map.getEntry(this); // 取出的值不为空的话，进行强制转换 if (e != null) { @SuppressWarnings("unchecked") T result = (T)e.value; return result; } } // ThreadLocalMap 为空或者值为空的话，就从 setInitialValue 中获取 return setInitialValue(); }
// ThreadLocal private T setInitialValue() { // 从 initialValue 方法中获取默认的值 默认的实现是返回 null T value = initialValue(); // 当前线程 Thread t = Thread.currentThread(); // 获取到线程的 ThreadLocalMap ThreadLocalMap map = getMap(t); // 不为空的话 set 设置进去 if (map != null) map.set(this, value); else // 创建 ThreadLocalMap 并初始化值 createMap(t, value); return value; }
3.3.1 ThreadLocalMap 的 getEntry 方法
当线程中的ThreadLocalMap 不为空的情况下，会调用 ThreadLocalMap 中的 getEntry来获取，我们看下：
// ThreadLocalMap private Entry getEntry(ThreadLocal<?> key) { // 获取当前 ThreadLocal 的索引位置 int i = key.threadLocalHashCode & (table.length - 1); // 获取到当前位置的 Entry Entry e = table[i]; // 不等于空的话，并且等于当前的 ThreadLocal 对象 if (e != null && e.get() == key) return e; else // 什么清空走这个？ 1、脏ThreadLocal 2、冲突了 return getEntryAfterMiss(key, i, e); }
// ThreadLocalMap private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) { // 当前的数组 Entry[] tab = table; // 数组的长度 int len = tab.length; // 循环直到 Entry 为空了 退出循环 while (e != null) { // 获取 Entry 的 key ThreadLocal<?> k = e.get(); // 等于当前的 ThreadLocal 直接返回 if (k == key) return e; // 脏了就清除掉继续循环 if (k == null) expungeStaleEntry(i); else // 下一个索引位置继续 i = nextIndex(i, len); e = tab[i]; } return null; }
3.4 remove 方法
我们最后再来看一个remove方法：
// ThreadLocal public void remove() { // 获取到当前线程的 ThreadLocalMap ThreadLocalMap m = getMap(Thread.currentThread()); // 不为空的话 调用ThreadLocalMap 的 remove if (m != null) m.remove(this); }
可以看到调用了 ThreadLocalMap 的 remove 方法，那么我们进去看看：
3.4.1 ThreadLocalMap 的 remove 方法
// ThreadLocalMap private void remove(ThreadLocal<?> key) { // 当前的数组 Entry[] tab = table; // 数组长度 int len = tab.length; // 获取当前 ThreadLocal 对应的索引位置 int i = key.threadLocalHashCode & (len-1); /** * 这里为什么要循环呢？ * 因为取余会得到的可能不是当前 ThreadLocal 的 * 因为会冲突 冲突后会往后存放，所以循环知道找到和当前的 ThreadLocal相等的 */ for (Entry e = tab[i]; e != null; e = tab[i = nextIndex(i, len)]) { if (e.get() == key) { // reference 的 弱引用置空 e.clear(); // 清理掉当前的 ThreadLocal expungeStaleEntry(i); return; } } }
remove方法比较简单，回收掉当前的 ThreadLocal占用的 Entry，其实也会进行其它 脏ThreadLocal的清理。
4 思考
4.1 大致的引用关系图
这里简单画了一下各个类型之间的引用关系，方便大家理解哈：
4.2 为什么重新扩容或者放置新的 ThreadLocal的时候都不加锁呢？也就是ThreadLocal为什么是无锁的呢？
你想从始至终我们的 ThreadLocalMap都是依附在当前线程中的，这些东西都是你自己的东西，没别的线程跟你抢，相当于 ThreadLocal对象都是对每个线程的一个副本，自己用自己的。
4.3 常说的 ThreadLocal的内存泄漏是怎么回事？
内存泄漏是什么意思：就是我们的垃圾回收不掉已经不用的空间，不再用到的内存，没有及时释放，就叫做内存泄漏。就会一直滞留在jvm中，导致可能会OOM，但是我们可以看到 set、get其实都会对脏的 ThreadLocal 进行 value强引用的解除，那么怎么还会有泄漏呢？难道是如果数据初始化好之后，一直不调用get、set等方法，这样Entry就一直不能回收，导致内存泄漏的么？
另一个理解Threadlocal本身的存活时间就比较长，当我们的线程池线程复用起来的话，每个线程往里边set完不主动remove的话是不是就内存泄漏了，一直得不到释放。
所以使用ThreadLocal会发生 内存泄漏的前提条件：
（1）线程长时间运行而没有被销毁。 线程池中的Thread实例很容易满足此条件。
（2）ThreadLocal引用被设置为null，且后续在同一Thread实例的执行期间，没有发生对其他 ThreadLocal实例的get、set或remove操作。
4.4 ThreadLocalMap中的 key 为什么是弱引用？
首先弱引用是当仅有弱引用（WeakReference）指向的对象，只能生存到下一次垃圾回收之前。换句话说，当GC发生时，不管内存够不够，仅有弱引用所指向的对象都会被回收。而拥有强引用 指向的对象，则不会被直接回收。
由于ThreadLocalMap中Entry的 Key 使用了弱引用，在下次GC发生时，就可以使那些没有被其他强引用指向、仅被Entry的Key 所指向的ThreadLocal实例能被顺利回收。并且，在Entry的Key引用被回收 之后，其Entry的Key值变为null。后续当ThreadLocal的 get 、 set 或 remove 被调用时， ThreadLocalMap的内部代码会清除这些Key为null的Entry，从而完成相应的内存释放。
举个例子：
public void funcA() { //创建一个线程本地变量 ThreadLocal local = new ThreadLocal<Integer>(); //设置值 local.set(100); //获取值 local.get(); //函数末尾 }
当线程执行完funcA方法后，funcA的方法栈帧将被销毁，强引用 local 的值也就没有了，但此时线程 的ThreadLocalMap里的对应的Entry的 Key 引用还指向了 ThreadLocal 实例。若Entry的 Key 引用是 强引用， 就会导致Key引用指向的ThreadLocal实例、及其Value值都不能被GC回收，这将造成严重的内存泄露.
5 小结
本节我们浏览了一下 ThreadLocal 的机制和原理，看了其核心的具体实现，有理解不对的地方欢迎指正哈。
