ThreadLocal的理解(一)

@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关键字都用于处理多线程并发访问变量的问题,不过两者处理问题的角度和思路不同。

SynchronizedThreadLocal
原理同步机制采用 以空间换时间 的方式,只提供了一份变量,让不同的线程排队访问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的方法,显然是为了让子类覆盖而设计的)
  • 1
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值