深入理解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,放入的数字:38


pool-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);
        else
            createMap(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置为null
                    e.clear();
                    //把value置为null，通常也会把key为null的value置为null
                    expungeStaleEntry(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);
        else
            createMap(t, value);
    }

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