深入理解ThreadLocal原理

以下内容首发于我的个人网站，来这里看更舒适：https://riun.xyz/work/9898775

ThreadLocal是一种用于实现线程局部变量的机制，它允许每个线程有自己独立的变量，从而达到了线程数据隔离的目的。

基于JDK8

使用

通常在项目中是这样使用它的，创建线程变量工具类，然后用它去存取线程局部变量：

package com.example.demo.Utils;/*** @author: HanXu* on 2021/11/17* Class description: 线程变量工具类* 在每一个线程中储存一个变量，以记录当前线程生命流程中的动作*/
public class ThreadLocalUtil {private static final ThreadLocal<String> currentThreadLocal = ThreadLocal.withInitial(() -> new String());/*** 获取值* @return 当前线程中存放的变量值*/public static String getCurrentThreadVal() {return currentThreadLocal.get();}/*** set值* @param value 唯一*/public static void putCurrentThreadVal(String value) {currentThreadLocal.set(value);}/*** 清空当前线程中的数据*/public static void clear() {currentThreadLocal.remove();}
}

有了这个工具类，我们就能在线程执行时为每个线程放入不同的数据了，以下是一个小测试：

package com.example.demo.Utils;import java.util.Random;
import java.util.concurrent.*;/*** @author: HanXu* on 2024/6/26* Class description: 向10个线程中放入随机数，然后取出，查看放入取出是否一致*/
public class Test {private static final int THREAD_NUM = 10;private static final CountDownLatch countDownLatch = new CountDownLatch(THREAD_NUM);private static final CyclicBarrier cyclicBarrier = new CyclicBarrier(THREAD_NUM);public static void main(String[] args) throws InterruptedException {ExecutorService threadPool = Executors.newFixedThreadPool(THREAD_NUM);for (int i = 0; i < THREAD_NUM; i++) {threadPool.execute(() -> {Random t = new Random();int num = t.nextInt(100);//等待所有线程都有任务再全部一起执行:在当前线程中放入100以内的随机数waitOtherThread();ThreadLocalUtil.putCurrentThreadVal(String.valueOf(num));System.out.println(Thread.currentThread().getName() + ",放入的数字:" + num);countDownLatch.countDown();});}countDownLatch.await();System.out.println();System.out.println();for (int i = 0; i < THREAD_NUM; i++) {threadPool.execute(() -> {//等待所有线程都有任务再全部一起执行:取出当前线程中存放的数字waitOtherThread();System.out.println(Thread.currentThread().getName() + ",取得数字:" + ThreadLocalUtil.getCurrentThreadVal());ThreadLocalUtil.clear();});}threadPool.shutdown();while (!threadPool.awaitTermination(3, TimeUnit.SECONDS)) {Thread.yield();}System.out.println("执行完毕!");}private static void waitOtherThread() {try {cyclicBarrier.await();} catch (InterruptedException e) {e.printStackTrace();} catch (BrokenBarrierException e) {e.printStackTrace();}}
}

执行结果：

pool-1-thread-10,放入的数字:80
pool-1-thread-8,放入的数字:22
pool-1-thread-7,放入的数字:52
pool-1-thread-6,放入的数字:99
pool-1-thread-5,放入的数字:91
pool-1-thread-3,放入的数字:26
pool-1-thread-4,放入的数字:25
pool-1-thread-1,放入的数字:64
pool-1-thread-2,放入的数字:56
pool-1-thread-9,放入的数字:38pool-1-thread-9,取得数字:38
pool-1-thread-10,取得数字:80
pool-1-thread-8,取得数字:22
pool-1-thread-7,取得数字:52
pool-1-thread-6,取得数字:99
pool-1-thread-5,取得数字:91
pool-1-thread-3,取得数字:26
pool-1-thread-4,取得数字:25
pool-1-thread-1,取得数字:64
pool-1-thread-2,取得数字:56
执行完毕!

原理

可以看到我们明明使用的是同一个ThreadLocal，但作用到不同线程上就能隔离他们之间的数据。那ThreadLocal是如何做到线程间数据隔离的呢？

我们可以看下ThreadLocal.set的源码：

	public void set(T value) {Thread t = Thread.currentThread();ThreadLocalMap map = getMap(t);if (map != null)map.set(this, value);elsecreateMap(t, value);}void createMap(Thread t, T firstValue) {t.threadLocals = new ThreadLocalMap(this, firstValue);}

可以看到通过getMap(t)，得到了一个类似Map的对象ThreadLocalMap，然后向map中存入数据时，是以当前对象this为key存入的。当前对象this就是当前ThreadLocal对象，我们使用的是同一个ThreadLocal，所以this是一样的。

那就肯定是map不同，再看下getMap(t)怎么获取的：

	ThreadLocalMap getMap(Thread t) {return t.threadLocals;}

Thread t是当前线程，t.threadLocals就是获取的当前线程的threadLocals属性。

（在Thread类里有一个成员属性：ThreadLocal.ThreadLocalMap threadLocals = null;）

那它的原理就是每个Thread内部有一个ThreadLocalMap类型的属性变量threadLocals。然后每个线程执行ThreadLocal.set时，是向自己的threadLocals中储存数据。由于线程不同，所以threadLocals也就不同，达到了线程数据隔离的目的。而ThreadLocal只是用来操作当前线程中的ThreadLocalMap的工具类而已。所有的数据并没有放在ThreadLocal当中。

所以一句话总结就是：每个线程有自己的ThreadLocalMap，存取数据是从自己的ThreadLocalMap操作的。

细节

ThreadLocalMap

ThreadLocalMap是一个Map，所以它也是数组+链表结构；但是由于我们使用的时候是一个ThreadLocal对象，而存数据时是以当前ThreadLocal对象作为key的，所以这个Map中只会有一个索引位置被使用，且不会有链表形成。（所以它内部并没有链表的实现）

Entry

我们再来看看Entry（ThreadLocal -> static class ThreadLocalMap -> static class Entry）：

		static class Entry extends WeakReference<ThreadLocal<?>> {/** The value associated with this ThreadLocal. */Object value;Entry(ThreadLocal<?> k, Object v) {super(k);value = v;}}

很简单的k,v键值对构成的对象，但是它却继承了弱引用WeakReference，让自己的k变成了弱引用类型：super(k); 为什么是弱引用的key我们后文再说。

remove

一般我们使用set存值，get取值，当这个变量不再使用了，我们需要手动remote()清除掉，ThreadLocal.remote()：

	public void remove() {ThreadLocalMap m = getMap(Thread.currentThread());if (m != null)m.remove(this);}

ThreadLocal.ThreadLocalMap.remote()：

		private void remove(ThreadLocal<?> key) {Entry[] tab = table;int len = tab.length;//获取ThreadLocal作为key在数组中的索引下标int i = key.threadLocalHashCode & (len-1);//虽然是循环，但是我们的使用方式数组中只会有一个索引有值for (Entry e = tab[i]; e != null; e = tab[i = nextIndex(i, len)]) {if (e.get() == key) {//使用的父类的clear方法，即：把key置为nulle.clear();//把value置为null，通常也会把key为null的value置为nullexpungeStaleEntry(i);return;}}}

我们在项目中使用ThreadLocal，在当前线程用完后，一定要手动remove()，这样在当前线程生命周期结束的时候，所有对象都会变为垃圾可回收。

内存泄露

如果我们在使用完ThreadLocal后，不手动remove()，若当前线程生命周期还未结束，那线程会一直持有ThreadLocalMap的引用，而ThreadLocalMap引用Entry，Entry引用了对应的key，value，而我们使用完了ThreadLocal，ThreadLocal已经没有了，就永远无法再获取这个Entry的key，value，这样就会造成了内存泄露：

所以正确的使用方法是：定义一个ThreadLocal，在线程运行时使用它，在使用完成之后执行remove()。

另外我们项目中一般都是用static final修饰ThreadLocal也是因为我们在项目运行期间只想要一个ThreadLocal对象，这样当发生一些不可预料的事情时，由于我们只有一个ThreadLocal对象，所以我们也能够操作之前这个位置的Entry内容，修改或删除它。

Why WeakReference?

通过上图我们可以看到，无论Entry的key使用强引用还是弱引用，如果没有remove()，那在线程生命周期没有结束时，都是会造成内存泄露的。那为什么要使用弱引用呢？

因为ThreadLocal的set / get /remove方法执行时，都会做一些额外的事：将key为null的Entry里的value也置为null：

    public void set(T value) {Thread t = Thread.currentThread();ThreadLocalMap map = getMap(t);if (map != null)//在这个方法内部map.set(this, value);elsecreateMap(t, value);}

这样，假设我们在某个方法中定义了ThreadLocal，使用完未remove()；而当我们下次在另一个方法中再定义一个ThreadLocal时，进行set / get /remove任意操作，都会将当前线程内ThreadLocalMap中key为null的Entry进行清除，将其value也置为null，将一个本该内存泄露的对象变为了可回收的垃圾。这样相当于多了一层保障，从而减少内存泄露发生的可能：