ThreadLocal 介绍与核心方法源码

最新推荐文章于 2024-09-15 19:46:31 发布

真的给劲儿

最新推荐文章于 2024-09-15 19:46:31 发布

阅读量3.3k

点赞数

分类专栏：学习小记文章标签： java

本文链接：https://blog.csdn.net/m0_55646363/article/details/127566368

版权

学习小记专栏收录该内容

7 篇文章 0 订阅

订阅专栏

CHENYu ren

1.ThreadLocal 介绍

1.1 JAVA官方文档介绍

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

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

总结:

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

1.2基本使用

1.2.1常用方法

几个ThreadLocal的常用方法

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

1.2.2 使用案例

感受ThreadLocal 线程隔离的特点

/**
 *  需求：线程隔离
 *         在多线程并发场景下，每个线程的变量必须都是相互独立的
 *         线程A： 设置 (变量1）    获取到的有必须是（变量1）
 *         线程B： 设置 (变量2）    获取到的有必须是（变量2）
 *         ThreadLocal:
 *             1.set()：将变量绑定到当前线程中
 *             2.get()：获取当前线程绑定的变量
 */
public class Wallet {
    //变量($$$$$$$$$$$$$)
    private Long money;

    private Long getMoney(){
        return money;
    }

    private void setMoney(Long money){
        this.money = money;
    }
    
    public static void main(String[] args) {
                        Wallet wallet = new Wallet();
                for (int i = 1; i <= 5; i++) {
                    Thread thread = new Thread(() -> {
                        wallet.setMoney(Long.valueOf(Thread.currentThread().getName()));
                        System.out.println("线程名：" + Thread.currentThread().getName() + "————取出——>" + wallet.getMoney());
            });
//线程名为i+00 正例：数据隔离访问共享变量即每个线程只会取出与线程名同等的money
            thread.setName(i + "00"); 
            thread.start();
        }
    }
}

输出：

线程名：100————取出——>300
线程名：400————取出——>400
线程名：500————取出——>500
线程名：300————取出——>300
线程名：200————取出——>300

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

/**
 *  需求：线程隔离
 *         在多线程并发场景下，每个线程的变量必须都是相互独立的
 *         线程A： 设置 (变量1）    获取到的有必须是（变量1）
 *         线程B： 设置 (变量2）    获取到的有必须是（变量2）
 *         ThreadLocal:
 *             1.set()：将变量绑定到当前线程中
 *             2.get()：获取当前线程绑定的变量
 */
public class Wallet {

    private ThreadLocal<Long> threadLocal = new ThreadLocal<>(); //改动1

    //变量($$$$$$$$$$$$$)
    private Long money;

    private Long getMoney(){
        return threadLocal.get(); //改动2
//        return money;
    }

    private void setMoney(Long money){
//        this.money = money;
        threadLocal.set(money); //改动3
    }
    public static void main(String[] args) {
                        Wallet wallet = new Wallet();
                for (int i = 1; i <= 5; i++) {
                    Thread thread = new Thread(() -> {
                        wallet.setMoney(Long.valueOf(Thread.currentThread().getName()));
                        System.out.println("线程名：" + Thread.currentThread().getName() + "————取出——>" + wallet.getMoney());
            });
            //线程名为i+00 | 线程 100、200、300、400、500 正例：数据隔离访问共享变量即每个线程只会取出与线程名同等的money
            thread.setName(i + "00"); //
            thread.start();
        }
    }
}

线程名：100————取出——>100
线程名：400————取出——>400
线程名：500————取出——>500
线程名：200————取出——>200
线程名：300————取出——>300
//使用ThreadLocal解决线程数据不隔离问题

1.3 ThreadLocal类与synchronized关键字

1.3.1 synchronized同步方式

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

    public static void main(String[] args) {
        Wallet wallet = new Wallet();
        for (int i = 1; i <= 5; i++) {
            Thread thread = new Thread(() -> {
                synchronized (Wallet.class){ //修改1
                    wallet.setMoney(Long.valueOf(Thread.currentThread().getName()));
                    System.out.println("线程名：" + Thread.currentThread().getName() + "————取出——>" + wallet.getMoney());
                }
            });
//线程名为i+00 正例：数据隔离访问共享变量即每个线程只会取出与线程名同等的money
            thread.setName(i + "00");
            thread.start();
        }
    }

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

1.3.2 ThreadLocal与synchronized的区别

虽然ThreadLocal模式与synchronized关键字都用于处理多线程并发访问变量的问题, 不过两者处理问题的角度和思路不同。

synchronized使代码块同步单线程的形式运行增加运行时间

ThreadLocal为每个线程提供变量副本，实现同时访问胡不干扰，利用空间节省了时间

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

虽然使用ThreadLocal和synchronized都能解决问题,但是使用ThreadLocal更为合适,因为这样可以使程序拥有更高的并发性。

2. ThreadLocal的内部结构

2.1. DK1.8之前早期的设计

每个ThreadLocal都创建一个Map，然后用线程Thread作为Map的key，要存储的局部变量作为Map的value，这样就能达到各个线程的局部变量隔离的效果。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-J6syISbR-1666922926038)(D:\KaiFa\typora\development\images\20210124115504330.png)]

2.2 现在的设计

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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sDbBDPdC-1666922926040)(D:\KaiFa\typora\development\images\20210124120125266-1666796398089.png)]

具体流程：

● 每个Thread线程内部都有一个Map (ThreadLocalMap)

● Map里面存储ThreadLocal对象（key）和线程的变量副本（value）

● Thread内部的Map是由ThreadLocal维护的，由ThreadLocal负责向map获取和设置线程的变量值。

● 对于不同的线程，每次获取副本值时，别的线程并不能获取到当前线程的副本值，形成了副本的隔离，互不干扰。

2.3 这样设计的好处

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

3.ThreadLocal的核心方法源码

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

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

3.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);
    }

(1)代码执行流程

首先获取当前线程，并根据当前线程获取一个Map

如果获取的Map不为空，则将参数设置到Map中（当前ThreadLocal的引用作为key）

如果Map为空，则给该线程创建 Map，并设置初始值

3.2 get方法

 /**
     * 返回当前线程中保存ThreadLocal的值
     * 如果当前线程没有此ThreadLocal变量，
     * 则它会通过调用{@link #initialValue} 方法进行初始化值
     *
     * @return 返回当前线程对应此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;
    }

(2)代码执行流程

首先获取当前线程, 根据当前线程获取一个Map

如果获取的Map不为空，则在Map中以ThreadLocal的引用作为key来在Map中获取对应的Entry e，否则转到4

如果e不为null，则返回e.value，否则转到4

Map为空或者e为空，则通过initialValue函数获取初始值value，然后用ThreadLocal的引用和value作为firstKey和firstValue创建一个新的Map

总结: 先获取当前线程的 ThreadLocalMap 变量，如果存在则返回值，不存在则创建并返回初始值。

3.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);
     }

（3) 代码执行流程

首先获取当前线程，并根据当前线程获取一个Map

如果获取的Map不为空，则移除当前ThreadLocal对象对应的entry

3.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的方法，显然是为了让子类覆盖而设计的）
adLocal线程局部变量有一个除null以外的初始值，

必须通过子类继承{@code ThreadLocal} 的方式去重写此方法
通常, 可以通过匿名内部类的方式实现
@return 当前ThreadLocal的初始值
*/
protected T initialValue() {
return null;
}


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

> （1） 这个方法是一个延迟调用方法，从上面的代码我们得知，在set方法还未调用而先调用了get方法时才执行，并且仅执行1次。
>
> （2）这个方法缺省实现直接返回一个null。
>
> （3）如果想要一个除null之外的初始值，可以重写此方法。（备注： 该方法是一个protected的方法，显然是为了让子类覆盖而设计的）
>