ThreadLocal的理解(一)

最新推荐文章于 2022-04-07 09:12:36 发布

fanjia2shao

最新推荐文章于 2022-04-07 09:12:36 发布

阅读量106

点赞数 1

分类专栏： java

本文链接：https://blog.csdn.net/fanjia2shao/article/details/112846936

版权

java 专栏收录该内容

18 篇文章 0 订阅

订阅专栏

@TOC

ThreadLocal介绍

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

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

线程并发：在多线程并发的场景下
传递数据：我们可以通过ThreadLocal在同一线程，不同组件之间传递公共变量（有点类似于Session？）
线程隔离：每个线程的变量都是独立的，不会互相影响

基本使用

在介绍Thread使用之前，我们首先认识几个Thread的常见方法

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

使用案例

我们来看下面这个案例，感受一下ThreadLocal线程隔离的特点


/**

 * 需求：线程隔离

 * 在多线程并发的场景下，每个线程中的变量都是相互独立的

 * 线程A：设置变量1，获取变量2

 * 线程B：设置变量2，获取变量2

 * @author: 

 * @create: 2020-07-10-17:03

 */

public class MyDemo01 {

    // 变量

    private String content;



    public String getContent() {

        return content;

    }



    public void setContent(String content) {

        this.content = content;

    }



    public static void main(String[] args) {

        MyDemo01 myDemo01 = new MyDemo01();

        for (int i = 0; i < 5; i++) {

            new Thread(() -> {

                myDemo01.setContent(Thread.currentThread().getName() + "的数据");

                System.out.println("-----------------------------------------");

                System.out.println(Thread.currentThread().getName() + "\t  " + myDemo01.getContent());

            }, String.valueOf(i)).start();

        }

    }

}

运行后的效果


-----------------------------------------

-----------------------------------------

-----------------------------------------

3	  4的数据

-----------------------------------------

2	  4的数据

-----------------------------------------

1	  4的数据

4	  4的数据

0	  4的数据

从上面我们可以看到，出现了线程不隔离的问题，也就是线程1取出了线程4的内，那么如何解决呢？

这个时候就可以用到ThreadLocal了，我们通过 set 将变量绑定到当前线程中，然后 get 获取当前线程绑定的变量


/**

 * 需求：线程隔离

 * 在多线程并发的场景下，每个线程中的变量都是相互独立的

 * 线程A：设置变量1，获取变量2

 * 线程B：设置变量2，获取变量2

 * @author: 

 * @create: 2020-07-10-17:03

 */

public class MyDemo01 {

    // 变量

    private String content;



    public String getContent() {

        return content;

    }



    public void setContent(String content) {

        this.content = content;

    }



    public static void main(String[] args) {

        MyDemo01 myDemo01 = new MyDemo01();

        ThreadLocal<String> threadLocal = new ThreadLocal<>();

        for (int i = 0; i < 5; i++) {

            new Thread(() -> {

                threadLocal.set(Thread.currentThread().getName() + "的数据");

                System.out.println("-----------------------------------------");

                System.out.println(Thread.currentThread().getName() + "\t  " + threadLocal.get());

            }, String.valueOf(i)).start();

        }

    }

}

我们引入ThreadLocal后，查看运行结果


-----------------------------------------

-----------------------------------------

4	  4的数据

-----------------------------------------

3	  3的数据

-----------------------------------------

2	  2的数据

-----------------------------------------

1	  1的数据

0	  0的数据

我们发现不会出现上面的情况了，也就是当前线程只能获取线程线程存储的对象

ThreadLocal类和Synchronized关键字

Synchronized同步方式

对于上述的例子，我们完全可以通过加锁的方式来实现这个功能，我们来看一下用Synchronized代码块实现的效果：


    public static void main(String[] args) {

        MyDemo03 myDemo01 = new MyDemo03();

        for (int i = 0; i < 5; i++) {

            new Thread(() -> {

                synchronized (MyDemo03.class) {

                    myDemo01.setContent(Thread.currentThread().getName() + "的数据");

                    System.out.println("-----------------------------------------");

                    System.out.println(Thread.currentThread().getName() + "\t  " + myDemo01.getContent());

                }

            }, String.valueOf(i)).start();

        }

    }

运行结果如下所示，我们发现我们可以看到同样实现了功能，但是并发性降低了


-----------------------------------------

0	  0的数据

-----------------------------------------

4	  4的数据

-----------------------------------------

3	  3的数据

-----------------------------------------

2	  2的数据

-----------------------------------------

1	  1的数据

ThreadLocal与Synchronized的区别

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

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

总结：在刚刚的案例中，虽然使用ThreadLocal和Synchronized都能解决问题，但是使用ThreadLocal更为合适，因为这样可以使程序拥有更高的并发性。

运用场景

转账案例

这里们先构建一个简单的转账场景：有一个数据表account，里面有两个用户 jack 和 Rose，用户Jack给用户Rose转账。案例的实现主要是用mysql数据库，JDBC和C3P0框架，以下是详细代码
在这里插入图片描述

引入事务

案例中转账涉及两个DML操作：一个转出，一个转入。这些操作是需要具备原子性的，不可分割。不然有可能出现数据修改异常情况。


public class AccountService {

    public boolean transfer(String outUser, String isUser, int money) {

        AccountDao ad = new AccountDao();

        try {

            // 转出

            ad.out(outUser, money);

            // 模拟转账过程中的异常

            int i = 1/0;

            // 转入

            ad.in(inUser, money);

        } catch(Exception e) {

            e.printStackTrace();

            return false;

        }

        return true;

    }

}

所以这里就需要操作事务，来保证转入和转出具备原子性，要么成功，要么失败。

JDBC中关于事务操作的API

Connection接口的方法	作用
void setAutoCommit(false)	禁用事务自动提交（改为手动提交）
void commit()	提交事务
void rollbakc()	回滚事务

开启事务的注意点

为了保证所有操作在一个事务中，案例中使用的连接必须是同一个；service层开启事务的connection需要跟dao层访问数据库的connection保持一致

线程并发情况下，每个线程只能操作各自的connection，也就是线程隔离

常规解决方法

基于上面给出的前提，大家通常想到的解决方法

从service层将connection对象向dao层传递

加锁

常规解决方法的弊端

提高代码的耦合度（因为我们需要从service 层传入 connection参数）

降低程序的性能（加了同步代码块，失去了并发性）

这个时候就可以通过ThreadLocal和当前线程进行绑定，来降低代码之间的耦合
在这里插入图片描述

使用ThreadLocal解决

针对上面出现的情况，我们需要对原来的JDBC连接池对象进行更改

将原来从连接池中获取对象，改成直接获取当前线程绑定的连接对象

如果连接对象是空的

再去连接池中获取连接

将此连接对象跟当前线程进行绑定


ThreadLocal<Connection> tl = new ThreadLocal();

public static Connection getConnection() {

    Connection conn = tl.get();

    if(conn == null) {

        conn = ds.getConnection();

        tl.set(conn);

    }

    return conn;

}

ThreadLocal实现的好处

从上述的案例中我们可以看到，在一些特定场景下，ThreadLocal方案有两个突出的优势：

传递数据：保存每个线程绑定的数据，在需要的地方可以直接获取，避免参数直接传递带来的代码耦合问题

线程隔离：各线程之间的数据相互隔离却又具备并发性，避免同步方式带来的性能损失

ThreadLocal的内部结构

现在我们一起来看一下ThreadLocal的内部结构，探究它能够实现线程数据隔离的原理。

常见误解

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

现在的设计

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

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

在这里插入图片描述

对比

在这里插入图片描述
从上面变成JDK8的设计有什么好处？

每个Map存储的Entry数量变少，因为原来的Entry数量是由Thread决定，而现在是由ThreadLocal决定的

真实开发中，Thread的数量远远大于ThreadLocal的数量

当Thread销毁的时候，ThreadLocalMap也会随之销毁，因为ThreadLocal是存放在Thread中的，随着Thread销毁而消失，能降低开销。

ThreadLocal核心方法源码

set方法

在这里插入图片描述

代码流程

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

get方法

在这里插入图片描述

代码执行流程

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

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

remove方法

在这里插入图片描述
代码执行流程

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

initialValue方法

在这里插入图片描述
此方法的作用是返回该线程局部变量的初始值。

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

fanjia2shao

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
ThreadLocal的理解(一)

@TOCThreadLocal介绍从Java官方文档中的描述：ThreadLocal类用来提供线程内部的局部变量。这种变量在多线程环境下访问（通过get和set方法访问）时能保证各个线程的变量相对独立于其他线程内的变量。ThreadLocal实例通常来说都是private static类型的，用于关联线程和线程上下文。我们可以得知ThreadLocal的作用是：提供线程内的局部变量，不同的线程之间不会相互干扰，这种变量在线程的生命周期内起作用，减少同一个线程内多个函数或组件之间一些公共变量传递的复杂度
复制链接

扫一扫

专栏目录