多线程-线程本地变量ThreadLocal

简介

ThreadLocal是线程本地变量，用于存储独属于线程的变量，这些变量可以在同一个线程内跨方法、跨类传递。每一个ThreadLocal对象，只能为当前线程关联一个数据，如果要为当前线程关联多个数据，就需要使用多个ThreadLocal实例

常用操作：ThreadLocal有set、get、remove三个动作，分别对应存储、获取、清除

ThreadLocal的实际应用：

• 案例1：jdbc中使用ThreadLocal来存储数据库连接，从而实现事务控制的功能。ThreadLocal可以保证同一个线程内获取到的数据库连接是同一个，用户可以在这个连接下开启事务、执行sql、提交事务。
• 案例2：在某些业务系统中，会使用ThreadLocal来存储发起当前请求的用户的信息，当请求来临时，把用户信息放到ThreadLocal中，处理完请求后，清理ThreadLocal中的用户信息，这样，在处理请求时，在业务代码中就可以通过ThreadLocal来获取用户信息。

ThreadLocal的运行机制：

• 向ThreadLocal中设置元素时，ThreadLocal会获取当前线程对象中的ThreadLocalMap实例，
  • 如果可以获取到，ThreadLocal会把自己作为键，set方法的参数作为值，存储到ThreadLocalMap中，
  • 如果获取不到，就创建一个ThreadLocalMap

使用案例

案例1：基本使用

基本使用，这里演示了ThreadLocal的set、get、remove

private static final ThreadLocal<String> LOCAL = new ThreadLocal<>();

public static void main(String[] args) {
    // 向threadLocal中存入变量
    LOCAL.set("aaa");
    // 获取变量
    System.out.println("local.get() = " + LOCAL.get()); // aaa
    // 移除变量
    LOCAL.remove();
    System.out.println("local.get() = " + LOCAL.get()); // null
}

案例2：多个线程操作同一个ThreadLocal

多个线程操作同一个ThreadLocal实例，同时向里面设置元素、获取元素，验证会不会出现线程安全问题？

private static final ThreadLocal<Object> LOCAL_VAR = new ThreadLocal<>();

public static void main(String[] args) {
    // 线程1
    new Thread(() -> {
        LOCAL_VAR.set(Thread.currentThread().getName());
        Utils.println(LOCAL_VAR.get());  // t1
        LOCAL_VAR.remove();
        Utils.println("after remove : " + LOCAL_VAR.get()); // null
    },"t1").start();

    // 线程2
    new Thread(() -> {
        LOCAL_VAR.set(Thread.currentThread().getName());
        Utils.println(LOCAL_VAR.get());  // t2
        LOCAL_VAR.remove();
        Utils.println("after remove : " + LOCAL_VAR.get()); // null
    },"t2").start();
}

总结：不会出现线程安全问题。原因随后讲

案例3：一个线程操作多个ThreadLocal

private static final ThreadLocal<Object> LOCAL_VAR = new ThreadLocal<>();
private static final ThreadLocal<Object> LOCAL_VAR_2 = new ThreadLocal<>();

public static void main(String[] args) {
    new Thread(() -> {
        // 设置并打印本地变量
        LOCAL_VAR.set("aa");
        LOCAL_VAR_2.set("bb");

        Utils.println(LOCAL_VAR.get()); // aa
        Utils.println(LOCAL_VAR_2.get()); // bb

        // 清除本地内存中的本地变量
        LOCAL_VAR.remove();
        LOCAL_VAR_2.remove();
    },"t1").start();
}

总结：如果线程需要n个本地局部变量，那么它就需要使用n个ThreadLocal实例，一个ThreadLocal实例对应当前线程中的一个本地变量

案例4：使用ThreadLocal，实现线程间的数据隔离

java1.1提供的日期类是线程不安全的，这里使用ThreadLocal来解决线程安全的问题

public static void main(String[] args) {
    ThreadLocal<SimpleDateFormat> dateFormatThreadLocal = new ThreadLocal<>();

    for(int i = 0; i < 10; i++) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                // 创建一个格式化日期的实例，然后存放到ThreadLocal中
                dateFormatThreadLocal.set(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
                Date date = null;
                try {
                    date = dateFormatThreadLocal.get().parse("2021-08-15 12:08:09");
                } catch (ParseException e) {
                    e.printStackTrace();
                }
                Utils.println("date = " + date);
                dateFormatThreadLocal.remove();
            }
        }).start();
    }
}

总结：SimpleDateFormat本身是线程不安全的，在这个案例中，每个线程都会创建一个SimpleDateFormat实例，然后存入到ThreadLocal中，使用时再从ThreadLocal中取出，避免多个线程复用同一个SimpleDateFormat实例，从而实现线程安全。在实际使用中，这也是一种解决问题的方式。但是，ThreadLocal最常见的操作还是用于在同一个线程内跨方法、跨类传递变量，通常不会考虑用ThreadLocal来实现线程安全，因为这样做消耗也会成倍增加，例如在本案例中，有几个线程，就需要几个SimpleDateFormat实例。常见的策略是，考虑把多线程共享的实例做成无状态的，只负责计算，不存储数据，如果确实需要访问共享资源，可以使用锁。

源码分析

ThreadLocal的类结构

public class ThreadLocal<T> {  // 泛型T，是ThreadLocal中存储的元素的数据类型
    // 静态内部类ThreadLocalMap
    static class ThreadLocalMap {
        // 静态内部类中还有一个静态内部类 Entry，注意，这里Entry继承了WeakReference，它代表弱引用
        static class Entry extends WeakReference<ThreadLocal<?>> {
            // 这里的value就是ThreadLocal调用set时存入的值
            Object value;

            Entry(ThreadLocal<?> k, Object v) {
                super(k);  // key是弱引用
                value = v;
            }
        }

        // 存储变量的数据结构
        private Entry[] table;
        private int size = 0;
        private int threshold;
    }
}

// Thread类中持有ThreadLocalMap的引用，这就是线程局部变量存放的地方
public class Thread implements Runnable {
    ThreadLocal.ThreadLocalMap threadLocals = null;
}

总结：这里最关键的是ThreadLocalMap，它被声明在ThreadLocal中，同时，Thread持有ThreadLocalMap的实例，这个实例中存放的就是线程本地变量。而且要注意，ThreadLocalMap中的Entry，它用于包装键值对，键是弱引用，随后会学习到。

set方法

用户调用set方法，向当前线程存入一个局部变量

// ThreadLocal中的set方法
public void set(T value) {
    // 获取当前线程对象
    Thread t = Thread.currentThread();
    // 获取线程对象内ThreadLocalMap类型的成员变量
    ThreadLocalMap map = getMap(t);
    // 如果map不等于null，以当前threadLocal对象作为键，把用户指定的值设置到map中
    if (map != null)
        map.set(this, value);
    else
        // 创建map对象，设置键值对
        createMap(t, value);
}

最终会把变量设置到ThreadLocalMap中，注意，在这个map中，key是ThreadLocal，值是set方法的参数

get方法

获取ThreadLocal在当前线程实例中对应的值

public T get() {
    // 获取当前线程对象
    Thread t = Thread.currentThread();
    // 获取线程对象内ThreadLocalMap类型的成员变量
    ThreadLocalMap map = getMap(t);
    // 如果map不等于null
    if (map != null) {
        // 以当前threadLocal对象作为键，获取键值对
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {
            // 获取键值对中的值
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    // 如果map等于null，这里是将键置为当前对象，值置为null，然后返回null值
    return setInitialValue();
}

同样，这里是从Thread实例中获取ThreadLocalMap的实例，然后使用ThreadLocal作为key，从ThreadLocalMap中获取value，remove方法也类似

ThreadLocalMap

ThreadLocalMap，顾名思义，它是一个map，存储键值对，在之前学习set、get方法时，发现所有的变量最终都会存储到其中，并且key是ThreadLoal。在这里深入了解ThreadLocalMap是如何存储数据的。

ThreadLocalMap类似于HashMap，底层是数组，根据key的哈希值，计算下标，然后把元素存放到下标处，和HashMap不同的在于，如果有冲突，它没有采用链地址法来处理冲突，而是把元素直接存放到 下标 + 1 的位置，如果 下标 + 1 = 数组长度，直接把元素存入第0位，然后一直循环，直到找到空位。

ThreadLocalMap的成员变量：

static class ThreadLocalMap {
    private Entry[] table;  // 存储元素的底层数组
    private int size = 0;   // 元素个数
    private static final int INITIAL_CAPACITY = 16;  // 数组的初始容量
    private int threshold;  // 阈值，决定何时扩容

    // 构造方法，构造方法的参数是第一个键值对，会把它们存入数组中。
    ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) {
        table = new Entry[INITIAL_CAPACITY];
        // 计算下标
        int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
        table[i] = new Entry(firstKey, firstValue);
        size = 1;
        setThreshold(INITIAL_CAPACITY);
    }

}

存放键值对的方法：set方法（这里是ThreadLocalMap中的set方法，不是ThreadLocal中的）

// 参数是键值对，注意，键是ThreadLocal
private void set(ThreadLocal<?> key, Object value) {
    Entry[] tab = table;
    int len = tab.length;
    // 计算下标，哈希值和 数组长度 - 1 按位与，了解HashMap的这招都不陌生，
    // 数组长度要求必须是2的次方，按位与的结果是0到数组长度减1
    int i = key.threadLocalHashCode & (len-1);

    // for循环，如果进入循环，表示下标处已经有值，就需要处理哈希冲突
    for (Entry e = tab[i];
         e != null;
         e = tab[i = nextIndex(i, len)]) {
        ThreadLocal<?> k = e.get();

        // 如果新增的key和原先的key一样，更新value
        if (k == key) {
            e.value = value;
            return;
        }

        // 如果key是null，清理value。这里证明发生了内存泄漏，
        // 因为key都没有了，但是值还在，所以需要清理value，随后详细讲解。
        if (k == null) {
            replaceStaleEntry(key, value, i);
            return;
        }
    }

    // 循环结束，证明找到了可以存放元素位置，存放元素
    tab[i] = new Entry(key, value);
    int sz = ++size;
    // 如果元素个数大于阈值，扩容
    if (!cleanSomeSlots(i, sz) && sz >= threshold)
        rehash();
}

根据键获取值的方法：getEntry方法

private Entry getEntry(ThreadLocal<?> key) {
    // 计算下标，获取元素
    int i = key.threadLocalHashCode & (table.length - 1);
    Entry e = table[i];
    if (e != null && e.get() == key)
        // 如果键值对中键是匹配的，返回键值对
        return e;
    else
        // 如果没有找到元素，可能发生了哈希冲突，需要继续寻找
        return getEntryAfterMiss(key, i, e);
}

// TgetEntryAfterMiss方法，处理哈希冲突
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)
            return e;
        // 如果键等于null，将value置为null，同样涉及到内存泄漏
        if (k == null)
            expungeStaleEntry(i);
        else
            // 下一个下标
            i = nextIndex(i, len);
        e = tab[i];
    }
    return null;
}

总结：这一节描述了ThreadLocalMap是如何存储和获取元素的，和普通的map基本类似，只不过它使用了再寻址法来处理哈希冲突。

ThreadLocalMap的工作机制：在学习了一部分ThreadLocal的源码之后，这里用文字和图片总结一下ThreadLocal的工作机制

工作机制：

• ThreadLocal内部定义了ThreadLocalMap
• Thread类持有ThreadLocalMap的实例
• ThreadLocalMap中维护了一个数组，数组中的每一个元素都是一个键值对，键是当前ThreadLocal实例，值是用户设置的值。
• 同一个线程操作的多个ThreadLocal实例，都存储在一个ThreadLocalMap中
• 多个线程操作同一个ThreadLocal实例，每个线程都有自己的ThreadLocalMap，key是同一个，但map有多个，key对应的值分别存储在不同的map中。

时序图：

![外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传](https://img-home.csdnimg.cn/images/20230724024159
png?origin_url=.%2Fimage%2F3.%E5%A4%9A%E7%BA%BF%E7%A8%8B-%E7%BA%BF%E7%A8%8B%E5%B1%80%E9%83%A8%E5%8F%98%E9%87%8F%2Fimage-20250227173936522.png&pos_id=img-NJ9FX13n-1741182359260)

ThreadLocal的内存泄漏

ThreadLocal内存泄露指的是，虽然ThreadLocalMap中的键被回收了，但是值还在

发生内存泄漏的原因：

1. 用户在自己编写的代码中声明的ThreadLocal对象，本身是一个强引用，这个ThreadLocal对象同时会作为ThreadLocalMap中的键，这个键是一个弱引用。
2. 只要用户代码中ThreadLocal类型的对象没被回收，它的值不等于null，那ThreadLocalMap中的key就不会在GC时被回收。
3. 如果用户代码中ThreadLocal类型的对象被置为null，ThreadLocalMap中的key会在GC时被回收，如果此前没有移除value，那么这个value就会无法被获取到
4. ThreadLocalMap是依附在Thread上的，只要Thread销毁，那ThreadLocalMap也会销毁，但是如果线程一直存在，value一直无法回收，就会造成内存泄漏

为什么要将ThreadLocalMap的key设置为弱引用呢？外界是通过ThreadLocal来对ThreadLocalMap进行操作的，假设外界使用ThreadLocal的对象被置null了，那ThreadLocalMap的强引用指向ThreadLocal也毫无意义，弱引用反而可以预防大多数内存泄漏的情况，毕竟被回收后，下一次调用set/get/remove时ThreadLocal内部会清除掉value

ThreadLocal针对内存泄漏做的保护措施：如果在操作ThreadLocal时，发现key为null，会将value清除掉，同时会遍历map，寻找是否还有这样的值

存在长期性内存泄露需要满足条件：ThreadLocal被回收、线程被复用、线程复用后不再调用ThreadLocal的set/get/remove方法

如何避免：一个set对应一个remove，一定要确保元素在不用之后被移除。