ThreadLocal 详解

Posted 2023-05-02 cjhtxdy

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了ThreadLocal 详解相关的知识，希望对你有一定的参考价值。

1.ThreadLocal是什么? / 为什么要使用ThreadLocal?

ThreadLocal是什么？

　　ThreadLocal就是一个java类，这个类的作用和线程局部变量有关。线程局部变量作用域是当前单个线程，在线程开始时分配，线程结束时回收。

　　ThreadLocal类位于java.lang包下，由JDK包提供。如果创建了一个ThreadLocal变量，那么访问这个变量的每个线程都会有这个变量的本地副本，多个线程操作这个变量的时候，其实是在操作自己本地内存里的变量，他们可以使用 get() 和 set() 方法来获取默认值或将其值更改为当前线程所存的副本的值，从而避免了线程安全问题。

为什么要使用ThreadLocal?

　　并发场景下，会存在多个线程同时修改一个共享变量的场景，这就可能会出现线程安全问题。为了解决线程安全问题，可以用加锁的方式，比如synchronized或者lock，但是加锁可能会导致系统变慢

2.ThreadLocal原理：

　　最终的变量是放在了当前线程的 ThreadLocalMap 中，并不是存在 ThreadLocal 上，ThreadLocal 可以理解为只是ThreadLocalMap的封装，传递了变量值。 ThrealLocal 类中可以通过Thread.currentThread()获取到当前线程对象后，直接通过getMap(Thread t)可以访问到该线程的ThreadLocalMap对象。

　　每个Thread中都具备一个ThreadLocalMap，而ThreadLocalMap可以存储以ThreadLocal为 key ，Object 对象为 value 的键值对。

　　比如我们在同一个线程中声明了两个 ThreadLocal 对象的话， Thread内部都是使用仅有的那个ThreadLocalMap 存放数据的，ThreadLocalMap的 key 就是 ThreadLocal对象，value 就是 ThreadLocal 对象调用set方法设置的值。

1.ThreadLocal的数据结构：

　　Thread类有一个类型为ThreadLocal.ThreadLocalMap的实例变量threadLocals，也就是说每个线程有一个自己的ThreadLocalMap。

　　ThreadLocalMap有自己的独立实现，可以简单地将它的key是ThreadLocal的一个弱引用，value为代码中放入的值。

　　每个线程在往ThreadLocal里放值的时候，都会往自己的ThreadLocalMap里存，读也是以ThreadLocal作为引用，在自己的map里找对应的key，从而实现了线程隔离。

2.GC 之后 key 是否为 null？

ThreadLocal详解（附面试题）

1.ThreadLocal介绍

从Java官方文档中的描述：ThreadLocal类用来提供线程内部的局部变量。这种变量在多线程环境下访问（通过get和set方法访问）时能保证各个线程的变量相对独立于其他线程内的变量。ThreadLocal实例通常来说都是private static类型的，用于关联线程和线程上下文。

我们可以得知 ThreadLocal 的作用是：提供线程内的局部变量，不同的线程之间不会相互干扰，这种变量在线程的生命周期内起作用，减少同一个线程内多个函数或组件之间一些公共变量传递的复杂度。

总结成三个特点：

线程并发：在多线程并发的场景下
传递数据：我们可以通过ThreadLocal在同一线程，不同组件中传递公共变量
线程隔离：每个线程的变量都是独立的，不会互相影响

2.基本使用

2.1 常用方法

ThreadLocal的常用方法：

方法声明	描述
ThreadLocal()	创建ThreadLocal对象
public void set( T value)	设置当前线程绑定的局部变量
public T get()	获取当前线程绑定的局部变量
public void remove()	移除当前线程绑定的局部变量

2.2 栗子

我们先来看一个案例：

/**
 * @author xppll
 * @date 2021/12/25 21:23
 */
public class MyDemo1 
    private String content;

    private String getContent() 
        return content;
    

    private void setContent(String content) 
        this.content = content;
    

    public static void main(String[] args) 
        MyDemo1 demo = new MyDemo1();
        for (int i = 0; i < 5; i++) 
            Thread thread = new Thread(() -> 
                demo.setContent(Thread.currentThread().getName() + "的数据");
                System.out.println("----------------------");
                System.out.println(Thread.currentThread().getName() + "--->" + demo.getContent());
            );
            thread.setName("线程" + i);
            thread.start();

其中一次结果：

从结果可以看出多个线程在访问同一个变量的时候出现的异常，线程间的数据没有隔离。下面我们来看下采用 ThreadLocal 的方式来解决这个问题：

/**
 * @author xppll
 * @date 2021/12/25 21:23
 */
public class MyDemo1 
    ThreadLocal<String> t1 = new ThreadLocal<>();
    private String content;

    private String getContent() 
        //获取当前线程绑定的变量
        return t1.get();
    

    private void setContent(String content) 
//        this.content = content;
        //变量content绑定到当前线程
        t1.set(content);
    

    public static void main(String[] args) 
        MyDemo1 demo = new MyDemo1();
        for (int i = 0; i < 5; i++) 
            Thread thread = new Thread(() -> 
                demo.setContent(Thread.currentThread().getName() + "的数据");
                System.out.println("----------------------");
                System.out.println(Thread.currentThread().getName() + "--->" + demo.getContent());
            );
            thread.setName("线程" + i);
            thread.start();

结果：

从结果来看，这样很好的解决了多线程之间数据隔离的问题，十分方便

2.3 ThreadLocal类与synchronized关键字

这里可能有的朋友会觉得在上述例子中我们完全可以通过加锁来实现这个功能。我们首先来看一下用synchronized代码块实现的效果：

/**
 * @author xppll
 * @date 2021/12/25 21:23
 */
public class MyDemo1 
    private String content;

    private String getContent() 
        return content;
    

    private void setContent(String content) 
        this.content = content;
    

    public static void main(String[] args) 
        MyDemo1 demo = new MyDemo1();
        for (int i = 0; i < 5; i++) 
            Thread thread = new Thread(() -> 
                synchronized (MyDemo1.class) 
                    demo.setContent(Thread.currentThread().getName() + "的数据");
                    System.out.println("----------------------");
                    System.out.println(Thread.currentThread().getName() + "--->" + demo.getContent());
                

            );
            thread.setName("线程" + i);
            thread.start();

结果：

从结果可以发现，加锁确实可以解决这个问题，但是在这里我们强调的是线程数据隔离的问题，并不是多线程共享数据的问题, 在这个案例中使用synchronized关键字是不合适的。而且这里使用synchronized性能会更低。使用ThreadLocal有更高的并发性。

两者区别：

	synchronized	ThreadLocal
原理	同步机制采用以时间换空间的方式，只提供了一份变量，让不同的线程排队访问	ThreadLocal采用以空间换时间的方式, 为每一个线程都提供了一份变量的副本，从而实现同时访问而相不干扰
侧重点	多个线程之间访问资源的同步	多线程中让每个线程之间的数据相互隔离

3.ThreadLocal 的内部结构

3.1 JDK8之前的设计

如果我们不去看源代码的话，可能会猜测ThreadLocal是这样子设计的：每个ThreadLocal都创建一个Map，然后用线程作为Map的key，要存储的局部变量作为Map的value，这样就能达到各个线程的局部变量隔离的效果。这是最简单的设计方法，JDK最早期的ThreadLocal 确实是这样设计的，但现在早已不是了。

3.2 JDK8的优化

JDK后面优化了设计方案，在JDK8中 ThreadLocal的设计是：每个Thread维护一个ThreadLocalMap，这个Map的key是ThreadLocal实例本身，value才是真正要存储的值Object。

具体的过程是这样的：

每个Thread线程内部都有一个Map (ThreadLocalMap)
Map里面存储ThreadLocal对象（key）和线程的变量副本（value）
Thread内部的Map是由ThreadLocal维护的，由ThreadLocal负责向map获取和设置线程的变量值。
对于不同的线程，每次获取副本值时，别的线程并不能获取到当前线程的副本值，形成了副本的隔离，互不干扰。

这样设计的好处：

这样设计之后每个Map存储的Entry数量就会变少。因为之前的存储数量由Thread的数量决定，现在是由ThreadLocal的数量决定。在实际运用当中，往往ThreadLocal的数量要少于Thread的数量。
当Thread销毁之后，对应的ThreadLocalMap也会随之销毁，能减少内存的使用。

4.ThreadLocal 的核心方法源码

基于ThreadLocal的内部结构，我们继续分析它的核心方法源码，更深入的了解其操作原理。

除了构造方法之外，ThreadLocal对外暴露的方法有以下4个：、

方法声明	描述
protected T initialValue()	返回当前线程局部变量的初始值
public void set( T value)	设置当前线程绑定的局部变量
public T get()	获取当前线程绑定的局部变量
public void remove()	移除当前线程绑定的局部变量

接下来对四个方法进行源码解析

4.1 set方法

对应源码：

/**
 * 设置当前线程对应的ThreadLocal的值
 *
 * @param value 将要保存在当前线程对应的ThreadLocal的值
     */
public void set(T value) 
    // 获取当前线程对象
    Thread t = Thread.currentThread();
    // 获取此线程对象中维护的ThreadLocalMap对象
    ThreadLocalMap map = getMap(t);
    // 判断map是否存在
    if (map != null)
        // 存在则调用map.set设置此实体entry
        map.set(this, value);
    else
        // 1）当前线程Thread 不存在ThreadLocalMap对象
        // 2）则调用createMap进行ThreadLocalMap对象的初始化
        // 3）并将 t(当前线程)和value(t对应的值)作为第一个entry存放至ThreadLocalMap中
        createMap(t, value);


/**
 * 获取当前线程Thread对应维护的ThreadLocalMap 
 * 
 * @param  t the current thread 当前线程
 * @return the map 对应维护的ThreadLocalMap 
 */
ThreadLocalMap getMap(Thread t) 
    return t.threadLocals;

/**
 * 创建当前线程Thread对应维护的ThreadLocalMap 
 *
 * @param t 当前线程
 * @param firstValue 存放到map中第一个entry的值
 */
void createMap(Thread t, T firstValue) 
    //这里的this是调用此方法的threadLocal
    t.threadLocals = new ThreadLocalMap(this, firstValue);

整体可以分为几步：

首先获取当前线程，并根据当前线程获取一个Map
如果获取的Map不为空，则将参数设置到Map中（当前ThreadLocal的引用作为key）
如果Map为空，则给该线程创建 Map，并设置初始值

4.2 get方法

对应源码：

/**
 * 返回当前线程中保存ThreadLocal的值
 */
public T get() 
    // 获取当前线程对象
    Thread t = Thread.currentThread();
    // 获取此线程对象中维护的ThreadLocalMap对象
    ThreadLocalMap map = getMap(t);
    // 如果此map存在
    if (map != null) 
        // 以当前的ThreadLocal 为 key，调用getEntry获取对应的存储实体e
        ThreadLocalMap.Entry e = map.getEntry(this);
        // 对e进行判空 
        if (e != null) 
            @SuppressWarnings("unchecked")
            // 获取存储实体 e 对应的 value值
            // 即为我们想要的当前线程对应此ThreadLocal的值
            T result = (T)e.value;
            return result;
        
    
    /*
    	初始化 : 有两种情况有执行当前代码
    	第一种情况: map不存在，表示此线程没有维护的ThreadLocalMap对象
    	第二种情况: map存在, 但是没有与当前ThreadLocal关联的entry
     */
    return setInitialValue();


/**
 * 初始化
 *
 * @return the initial value 初始化后的值
 */
private T setInitialValue() 
    // 调用initialValue获取初始化的值
    // 此方法可以被子类重写, 如果不重写默认返回null
    T value = initialValue();
    // 获取当前线程对象
    Thread t = Thread.currentThread();
    // 获取此线程对象中维护的ThreadLocalMap对象
    ThreadLocalMap map = getMap(t);
    // 判断map是否存在
    if (map != null)
        // 存在则调用map.set设置此实体entry
        map.set(this, value);
    else
        // 1）当前线程Thread 不存在ThreadLocalMap对象
        // 2）则调用createMap进行ThreadLocalMap对象的初始化
        // 3）并将 t(当前线程)和value(t对应的值)作为第一个entry存放至ThreadLocalMap中
        createMap(t, value);
    // 返回设置的值value
    return value;

整体可以分为几步：

首先获取当前线程, 根据当前线程获取一个Map
如果获取的Map不为空，则在Map中以ThreadLocal的引用作为key来在Map中获取对应的Entry e，否则转到4
如果e不为null，则返回e.value，否则转到4
Map为空或者e为空，则通过initialValue函数获取初始值value，然后用ThreadLocal的引用和value作为firstKey和firstValue创建一个新的Map

总结成一句话就是：先获取当前线程的 ThreadLocalMap 变量，如果存在则返回值，不存在则创建并返回初始值。

4.3 remove方法

对应源码：

/**
 * 删除当前线程中保存的ThreadLocal对应的实体entry
 */
public void remove() 
    // 获取当前线程对象中维护的ThreadLocalMap对象
    ThreadLocalMap m = getMap(Thread.currentThread());
    // 如果此map存在
    if (m != null)
        // 存在则调用map.remove
        // 以当前ThreadLocal为key删除对应的实体entry
        m.remove(this);

整体可以分为几步：

首先获取当前线程，并根据当前线程获取一个Map
如果获取的Map不为空，则移除当前ThreadLocal对象对应的entry

4.4 initialValue方法

对应源码：

/**
  * 返回当前线程对应的ThreadLocal的初始值
  
  * 此方法的第一次调用发生在，当线程通过get方法访问此线程的ThreadLocal值时
  * 除非线程先调用了set方法，在这种情况下，initialValue 才不会被这个线程调用。
  * 通常情况下，每个线程最多调用一次这个方法。
  *
  * <p>这个方法仅仅简单的返回null @code null;
  * 如果程序员想ThreadLocal线程局部变量有一个除null以外的初始值，
  * 必须通过子类继承@code ThreadLocal 的方式去重写此方法
  * 通常, 可以通过匿名内部类的方式实现
  *
  * @return 当前ThreadLocal的初始值
  */
protected T initialValue() 
    return null;

此方法的作用：返回该线程局部变量的初始值。

（1）这个方法是一个延迟调用方法，从上面的代码我们得知，在set方法还未调用而先调用了get方法时才执行，并且仅执行1次

（2）这个方法缺省实现直接返回一个null

（3）如果想要一个除null之外的初始值，可以重写此方法。（备注：该方法是一个protected的方法，显然是为了让子类覆盖而设计的）

5.ThreadLocalMap 源码分析

5.1 基本结构

ThreadLocalMap是ThreadLocal的内部类，没有实现Map接口，用独立的方式实现了Map的功能，其内部的Entry也是独立实现。如下图

成员变量

/**
 * 初始容量 —— 必须是2的整次幂
 */
private static final int INITIAL_CAPACITY = 16;

/**
 * 存放数据的table，Entry类的定义在下面分析
 * 同样，数组长度必须是2的整次幂。
 */
private Entry[] table;

/**
 * 数组里面entrys的个数，可以用于判断table当前使用量是否超过阈值。
 */
private int size = 0;

/**
 * 进行扩容的阈值，表使用量大于它的时候进行扩容。
 */
private int threshold; // Default to 0

跟HashMap类似：

INITIAL_CAPACITY代表这个Map的初始容量
table 是一个Entry 类型的数组，用于存储数据
size 代表表中的存储数目
threshold 代表需要扩容时对应 size 的阈值

存储结构 - Entry

/*
 * Entry继承WeakReference，并且用ThreadLocal作为key
 * 如果key为null(entry.get() == null)，意味着key不再被引用
 * 因此这时候entry也可以从table中清除
 */
static class Entry extends WeakReference<ThreadLocal<?>> 
    /** The value associated with this ThreadLocal. */
    Object value;

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

从源码就可以看出：

在ThreadLocalMap中，也是用Entry来保存K-V结构数据的。不过Entry中的key只能是ThreadLocal对象，这点在构造方法中已经限定死了
另外，Entry继承WeakReference，也就是key（ThreadLocal）是弱引用，其目的是将ThreadLocal对象的生命周期和线程生命周期解绑

5.2 弱引用和内存泄漏

先来了解一些概念：

内存相关概念

Memory overflow：内存溢出，没有足够的内存提供申请者使用。
Memory leak：内存泄漏，是指程序中已动态分配的堆内存由于某种原因程序未释放或无法释放，造成系统内存的浪费，导致程序运行速度减慢甚至系统崩溃等严重后果。内存泄漏的堆积终将导致内存溢出。

弱引用相关概念

关于Java中的引用可以参考我的这篇文章：【JVM】垃圾回收1-3节

我们接下来看几个问题，具体了解弱引用和内存泄漏：

① 我们先来看看如果key使用强引用会出现什么问题？

假设ThreadLocalMap中的key使用了强引用，此时ThreadLocal的内存图（实线表示强引用）如下：

假设在业务代码中使用完ThreadLocal ，threadLocal Ref被回收了。
但是因为threadLocalMap的Entry强引用了threadLocal，造成threadLocal无法被回收。
在没有手动删除这个Entry以及CurrentThread依然运行的前提下，始终有强引用链 threadRef->currentThread->threadLocalMap->entry，Entry就不会被回收（Entry中包括了ThreadLocal实例和value），导致Entry内存泄漏。
也就是说，ThreadLocalMap中的key使用了强引用，是无法完全避免内存泄漏的

② 我们在看看如果key使用弱引用呢？

ThreadLocalMap中的key使用了弱引用，此时ThreadLocal的内存图（实线表示强引用，虚线表示弱引用）如下：

同样假设在业务代码中使用完ThreadLocal ，threadLocal Ref被回收了。
由于ThreadLocalMap只持有ThreadLocal的弱引用，没有任何强引用指向threadlocal实例, 所以threadlocal就可以顺利被gc回收，此时Entry中的key=null。
但是在没有手动删除这个Entry以及CurrentThread依然运行的前提下，也存在有强引用链 threadRef->currentThread->threadLocalMap->entry -> value ，value不会被回收，而这块value永远不会被访问到了，导致value内存泄漏。
也就是说，ThreadLocalMap中的key使用了弱引用，也有可能内存泄漏。

③ 内存泄漏的真实原因是什么呢？

比较以上两种情况，我们就会发现，内存泄漏的发生跟ThreadLocalMap中的key是否使用弱引用是没有关系的。那么内存泄漏的的真正原因是什么呢？

如果想避免内存泄漏，都有两个前提：

只要在使用完ThreadLocal，调用其remove方法删除对应的Entry，就能避免内存泄漏。
由于ThreadLocalMap是Thread的一个属性，被当前线程所引用，所以它的生命周期跟Thread一样长。那么在使用完ThreadLocal之后，如果当前Thread也随之执行结束，ThreadLocalMap自然也会被gc回收，从根源上避免了内存泄漏。

综上，ThreadLocal内存泄漏的根源是：由于ThreadLocalMap的生命周期跟Thread一样长，如果没有手动删除对应key就会导致内存泄漏。

④ 为什么使用弱引用？

根据刚才的分析，我们知道了：无论ThreadLocalMap中的key使用哪种类型引用都无法完全避免内存泄漏，跟使用弱引用没有关系。

要避免内存泄漏有两种方式：

使用完ThreadLocal，调用其remove方法删除对应的Entry
使用完ThreadLocal，当前Thread也随之运行结束

也就是说，只要记得在使用完ThreadLocal及时的调用remove，无论key是强引用还是弱引用都不会有问题。那么为什么key要用弱引用呢？

事实上，在ThreadLocalMap中的set/getEntry方法中，会对key为null（也即是ThreadLocal为null）进行判断，如果为null的话，那么是会对value置为null的。
这就意味着使用完ThreadLocal，CurrentThread依然运行的前提下，就算忘记调用remove方法，弱引用比强引用可以多一层保障：使用完ThreadLocal，弱引用的ThreadLocal会被回收，key就会变成null，对应的value在下一次ThreadLocalMap调用set，get，remove中的任一方法的时候会被清除，从而避免内存泄漏。

5.3 hash冲突的解决

ThreadLocal的set()

public void set(T value) 
    Thread t = Thread.currentThread();
    ThreadLocal.ThreadLocalMap map = getMap(t);
    if (map != null)
        //调用了ThreadLocalMap的set方法
        map.set(this, value);
    else
        createMap(t, value);


ThreadLocal.ThreadLocalMap getMap(Thread t) 
    return t.threadLocals;


void createMap(Thread t, T firstValue) 
    //调用了ThreadLocalMap的构造方法
    t.threadLocals = new ThreadLocal.ThreadLocalMap(this, firstValue);

这个方法刚才分析过, 其作用是设置当前线程绑定的局部变量：

首先获取当前线程，并根据当前线程获取一个Map
如果获取的Map不为空，则将参数设置到Map中（当前ThreadLocal的引用作为key）（这里调用了ThreadLocalMap的set方法）
如果Map为空，则给该线程创建 Map，并设置初始值（这里调用了ThreadLocalMap的构造方法）

这段代码有两个地方分别涉及到ThreadLocalMap的两个方法, 我们接着分析这两个方法。

构造方法 ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue)

 /*
  * firstKey : ThreadLocal实例(this)
  * firstValue ： 要保存的线程本地变量
  */
ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) 
    //初始化table
    table = new ThreadLocal.ThreadLocalMap.Entry[INITIAL_CAPACITY];
    //计算索引(重点代码）
    int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
    //设置值
    table[i] = new ThreadLocal.ThreadLocalMap.Entry(firstKey, firstValue);
    size = 1;
    //设置阈值
    setThreshold(INITIAL_CAPACITY);

整个初始化过程就是：

首先创建一个长度为16的Entry数组
然后计算出firstKey对应的索引
然后存储到table中
最后设置size和threshold

我们这里重点分析int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);

① 首先关于firstKey.threadLocalHashCode：

private final int threadLocalHashCode = nextHashCode();

private static int nextHashCode() 
    return nextHashCode.getAndAdd(HASH_INCREMENT);

//AtomicInteger是一个提供原子操作的Integer类，通过线程安全的方式操作加减,适合高并发情况下的使用
private static AtomicInteger nextHashCode =  new AtomicInteger()ThreadLocal用法详解和原理
 ThreadLocal详解
 ThreadLocal详解（附面试题）
 ThreadLocal详解
 ThreadLocal 详解
 ThreadLocal类详解

ThreadLocal 详解

ThreadLocal详解（附面试题）

文章目录

ThreadLocal详解（附面试题）

1.ThreadLocal介绍

2.基本使用

2.1 常用方法

2.2 栗子

2.3 ThreadLocal类与synchronized关键字

3.ThreadLocal 的内部结构

3.1 JDK8之前的设计

3.2 JDK8的优化

4.ThreadLocal 的核心方法源码

4.1 set方法

4.2 get方法

4.3 remove方法

4.4 initialValue方法

5.ThreadLocalMap 源码分析

5.1 基本结构

5.2 弱引用和内存泄漏

5.3 hash冲突的解决