关于 ThreadLocal
用法
ThreadLocal 包装了一个 get 和 set 方法，在当前线程内，可以 get 到之前 set 进的值：
ThreadLocal<String> tl = new ThreadLocal<>();
tl.set("a");
String a = tl.get();
实现
ThreadLocal 的本质是每个线程有一个专属的 map，存取 ThreadLocal 对象时，会以该 ThreadLocal 对象为 key，存入的值为 value 进行存取。
get 和 set 方法
get 和 set 的代码如下：
public void set(T value) {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
}
ThreadLocalMap getMap(Thread t) {
return t.threadLocals;
}
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.
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();
}
public T get() {
Thread t = Thread.currentThread();
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;
}
}
return setInitialValue();
}
可以看出，即使同一个 ThreadLocal 对象在不同线程中进行 set，它的 get 方法取出的值也互不打扰。因为 ThreadLocal 的 set 方法并不是把一个值跟当前 ThreadLocal 对象关联起来，而是将当前 ThreadLocal 对象作为 key，在当前线程专属的 map 中和值进行关联。因此不同线程中进行 set 时，都会存入不同的 map 中。
Map 的实现
ThreadLocal 使用的 Map 不是 HashMap，而是自己实现的 Map。它将 key 和 value 封装成一个 Entry，然后用一个 table 来存该 Entry。获取索引的方式和 HashMap 类似，它是用 threadLocalHashCode 和 table 长度-1进行与操作，因此 table 的长度也需要是2的幂。当冲突时，它没有用链表，而是直接计算下一个地址：((i + 1 < len) ? i + 1 : 0)。
static class Entry extends WeakReference<ThreadLocal<?>> {
/** The value associated with this ThreadLocal. */
Object value;
Entry(ThreadLocal<?> k, Object v) {
super(k);
value = v;
}
}
WeakReference
包裹 ThreadLocal 和 Value 的 Entry 类继承自 WeakReference。WeakReference 的特点是，如果对象除了有弱引用指向它后没有其他强引用关联它，当进行年轻代垃圾回收时，该引用指向的对象就会被垃圾回收器回收。
先说为什么要用弱引用：
- 如果使用正常的引用方式的话，线程在使用过一个 ThreadLocal 对象并释放后，它所在的 Entry 对象，依然被线程的 ThreadLocalMap 所持有，同时 ThreadLocal 对象被 Entry 所持有，无法被回收。由于线程会被复用，ThreadLocalMap 中的 Entry 会越来越多，而且里面有大量的 Entry 是不会被访问的，因此造成了所谓的内存泄漏。
- 如果使用弱引用的话，线程在使用过一个 ThreadLocal 对象并释放后，在经历过一次 Yong GC 后，就会被回收。这样，只需要在 set 和 get 方法里对 Entry 的 ThreadLocal 对象做 null 值的判断，就能去清除这些 key 为 null 的 Entry 对象。这里注意，WeakReference 对象在经历 GC 时被回收的是它的 referent 对象，它本身被 Map 所持有，不会被回收。
内存泄漏
现在网上很多说法是，此时留下 value 就是内存泄漏，因为没法访问这个 value，它还占着内存。因此每次使用完后需要 tl.remove() 来移除这个 Entry，阿里的规范也是这么要求的。这样做是不错，不过我觉得这么做的话弱引用就没意义了，因为如果 map 是强引用的话，每次使用完后 remove，也能起到效果。同时，每次 get 和 set 时，本身也会移除 key 为 null 的 Entry。
不过根据这篇文章，get 和 set 并不能完全触达所有的 key 为 null 的 Entry，所以建议还是要 remove 掉不再使用的 ThreadLocal 变量。
线程资源泄漏
ThreadLocal 还会有个潜在的问题，就是如果线程进行了复用，比如线程池这种，线程在执行下一个方法时会带着持有上一个线程数据的 Map。可以通过下面的例子验证：
public class ThreadLocalTest {
public static void main(String[] args) throws InterruptedException {
ThreadLocal<String> tl = new ThreadLocal<>();
Runnable runnable = new Runnable() {
@Override
public void run() {
System.out.println(tl.get());
tl.set(LocalDateTime.now().toString());
System.out.println(tl.get());
}
};
ExecutorService threadPoolExecutor = Executors.newFixedThreadPool(1);
threadPoolExecutor.submit(runnable);
Thread.sleep(1000);
threadPoolExecutor.submit(runnable);
}
}
输出的结果是：
null
2022-03-15T14:48:02.310
2022-03-15T14:48:02.310
2022-03-15T14:48:03.233
不过这个本来就不是 bug 而是个 feature，如果真的是不能让其他线程拿到的数据，只要注意在 ThreadLocal 的生命周期在方法栈内即可。
用途
Spring 的 @Transaction 本质就是用 ThreadLocal 实现的。
