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

类详解

方法名	注释
void set(Object value)	设置当前线程的线程局部变量的值。
Object get()	该方法返回当前线程所对应的线程局部变量。
void remove()	将当前线程局部变量的值删除，目的是为了减少内存的占用，该方法是 JDK 5.0新增的方法。
protected Object initialValue()	返回该线程局部变量的初始值，该方法是一个 protected 的方法，显然是为了让子类覆盖而设计的。还没有set的情况下，调用 get 则返回 null。

源码分析

一、首先看下 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 变量还会存在。这就不仅仅是内存泄露的问题了，整个业务逻辑都可能会出错。