[Java知识库]ThreadLocal详解

ThreadLocal是什么？

ThreadLocal 很容易让人顾名思义，想当然地认为是一个“本地线程”。其实，ThreadLocal 并不是一个 Thread，而是 Thread 的局部变量，所以有人觉得它命名为 ThreadLocalVariable 更容易让人理解一些。

ThreadLocal 很多地方叫做线程本地变量，也有些地方叫做线程本地存储。它是用来提供线程级别变量，变量只对当前线程可见，该变量对其他线程而言是隔离的。相比与“使用锁控制共享变量访问顺序”的解决方案。ThreadLocal 通过空间换时间的方案，在每个线程中都创建了一个副本，规避了竞争问题，因为每个线程都有属于自己的变量。

应用场景

1. 在进行对象跨层传递的时候，使用 ThreadLocal 可以避免多次传递，打破层次间的约束；
2. 线程间数据隔离；
3. 进行事务操作，用于存储线程事务信息；
4. 数据库连接，Session 会话管理；

使用示例

import java.util.stream.IntStream;

/** @author Strive */
public class DemoThreadLocal {
  public static void main(String[] args) {
    ThreadLocal<String> local = new ThreadLocal<>();

    IntStream.range(0, 5)
        .forEach(
            x ->
                new Thread(
                        () -> {
                          local.set(Thread.currentThread().getName() + ":" + x);
                          System.out.println(
                              "线程："
                                  + Thread.currentThread().getName()
                                  + "的 local 值："
                                  + local.get());
                        })
                    .start());
  }
}

程序运行结果：

线程：Thread-0的 local 值：Thread-0:0
线程：Thread-4的 local 值：Thread-4:4
线程：Thread-3的 local 值：Thread-3:3
线程：Thread-2的 local 值：Thread-2:2
线程：Thread-1的 local 值：Thread-1:1

类详解

源码分析

一、首先看下 set 方法

public void set(T value) {
    // 首先获取当前线程
    Thread t = Thread.currentThread();
    // 获取线程中变量 ThreadLocal.ThreadLocalMap
    ThreadLocalMap map = getMap(t);
    // 如果不为空，直接赋值
    if (map != null)
        map.set(this, value);
    else
        //如果为空，初始化该线程对象的 map 变量，其中 key 为当前的 threadlocal 变量
        createMap(t, value);
}

/**
 * key 为当前的 threadlocal（this） 变量
 */
void createMap(Thread t, T firstValue) {
    t.threadLocals = new ThreadLocalMap(this, firstValue);
}

二、ThreadLocalMap

set 方法中第二行代码 ThreadLocalMap map = getMap(t);

ThreadLocalMap 为 ThreadLocal 的一个静态内部类，里面定义了 Entry 来存储 K-V结构数据。而且是继承的弱引用。在Entry内部使用 ThreadLocal 作为 key，使用我们设置的 value 作为 value。

static class Entry extends WeakReference<ThreadLocal<?>> {
    /** The value associated with this ThreadLocal. */
    Object value;

    Entry(ThreadLocal<?> k, Object v) {
        super(k);
        value = v;
    }
}

也就是说对于每个线程内部有个 ThreadLocal.ThreadLocalMap 变量来存储属于自己的线程变量。

三、get 方法

获取当前线程，然后通过 key threadlocal 获取 设置的value，就是这么简单！

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 变量时，其实就是在定义一个 Key。
• 当我们调用 set(v) 方法时，就是以当前 ThreadLocal 变量为 key，传入参数为 value，向 ThreadLocal.ThreadLocalMap 存数据。
• 当我们调用 get() 方法时，就是以当前 ThreadLocal 变量为 key，从 ThreadLocal.ThreadLocalMap 取对应的数据。

ThreadLocal和线程同步机制

首先聊聊他们是干嘛的，ThreadLocal 和线程同步机制都是为了解决多线程中相同变量的访问冲突问题。

同步机制中，通过对象的锁机制保证同一时间只有一个线程访问变量。这时该变量是多个线程共享的，使用同步机制要求程序慎密地分析什么时候对变量进行读写，什么时候需要锁定某个对象，什么时候释放对象锁等繁杂的问题，程序设计和编写难度相对较大。

ThreadLocal 从另一个角度来解决多线程的并发访问。ThreadLocal 会为每一个线程提供一个独立的变量副本，从而隔离了多个线程对数据的访问冲突。因为每一个线程都拥有自己的变量副本，从而也就没有必要对该变量进行同步了。ThreadLocal提供了线程安全的共享对象，在编写多线程代码时，可以把不安全的变量封装进 ThreadLocal。

概括起来说，对于多线程资源共享的问题，同步机制采用了**“以时间换空间”的方式，而 ThreadLocal 采用了“以空间换时间”**的方式。前者仅提供一份变量，让不同的线程排队访问，而后者为每一个线程都提供了一份变量，因此可以同时访问而互不影响。

扩展

ThreadLocalMap的Hash冲突解决办法

采用线性探测的方式，根据 key 计算 hash 值，如果出现冲突，则向后探测，当到哈希表末尾的时候再从0开始，直到找到一个合适的位置。

这种算法也决定了 ThreadLocalMap 不适合存储大量数据。

ThreadLocalMap的扩容问题

ThreadLocalMap 初始大小为 16，加载因子为 2/3，当 size 大于 threshold时，就会进行扩容。

扩容时，新建一个大小为原来数组长度的两倍的数组，然后遍历旧数组中的 entry 并将其插入到新的hash数组中，在扩容的时候，会把 key 为 null 的 Entry的 value 值设置为 null，以便内存回收，减少内存泄漏问题。

ThreadLocal 内存泄漏问题

首先我们要知道啥是内存泄漏呢？简单的说，就是东西放在内存里面，但你忘记它放哪里了，它占着一块内存，但是不能回收。当这样的东西越来越多，内存就吃紧，最终导致服务器宕机。

/**
* The entries in this hash map extend WeakReference, using
* its main ref field as the key (which is always a
* ThreadLocal object).  Note that null keys (i.e. entry.get()
* == null) mean that the key is no longer referenced, so the
* entry can be expunged from table.  Such entries are referred to
* as "stale entries" in the code that follows.
*/
static class Entry extends WeakReference<ThreadLocal<?>> {
    /** The value associated with this ThreadLocal. */
    Object value;

    Entry(ThreadLocal<?> k, Object v) {
        super(k);
        value = v;
    }
}

看注释：Note that null keys (i.e. entry.get()* == null)?mean that the key is no longer referenced, so the entry can be expunged from table。

意思就是：如果 key threadlocal 为 null 了，这个 entry 就可以清除了。ThreadLocal 是一个弱引用，当为 null 时，会被当成垃圾回收。

重点来了，突然我们 ThreadLocal 是 null 了，也就是要被垃圾回收器回收了，但是此时我们的 ThreadLocalMap（thread 的内部属性）生命周期和 Thread 的一样，它不会回收，这时候就出现了一个现象。那就是 ThreadLocalMap 的 key 没了，但是 value 还在，这就造成了内存泄漏。

解决办法：使用完 ThreadLocal 后，执行 remove 操作，避免出现内存溢出情况。

所以，如同 lock 的操作 最后要执行解锁操作一样，ThreadLocal 使用完毕一定记得执行remove 方法，清除当前线程的数值。

如果不 remove 当前线程对应的 VALUE, 就会一直存在这个值。

使用了线程池，可以达到“线程复用”的效果。但是归还线程之前记得清除 ThreadLocalMap，要不然再取出该线程的时候，ThreadLocal 变量还会存在。这就不仅仅是内存泄露的问题了，整个业务逻辑都可能会出错。