《蹲坑也能进大厂》多线程系列-ThreadLocal精讲(基础+源码)

前言

我:狗剩子,早上好啊,两天不见,还以为你跳槽进了阿三的公司呢!

狗剩子:你这是吃辣子放屁,带刺激性的,花Gie教程不看完,我跳什么槽。

我:哟呼,那你这两天去哪了?

狗剩子:我这不是闭关修炼,刚刚出关嘛!

我:.... 分析完毕,是条傻狗。

 

正文

我:狗哥狗哥,你可以和我说说 ThreadLocal是什么吗?上次阿香问我,我没回答上来,很尴尬啊?

不要怕,狗哥来教你。

ThreadLocal主要用来提供线程局部变量,也就是该变量只对当前线程可见。

ThreadLocal在其内部维护了一个数据结构(类似HashMap),当需要用到某个变量时,会在每个线程中创建了一个变量副本,然后通过set()get()来对该副本进行操作,从而实现线程之间的数据隔离

我:听起来也不是很难嘛!那我们平时都是在哪用到ThreadLocal 呢?

听起来虽然很简单,但是要想真正的掌握,也不是那么简单的事哦。倒杯茶,点个赞,且听老衲细细道来,下面举几个常用的案例。

《蹲坑也能进大厂》多线程系列-ThreadLocal精讲(基础+源码)

1) SimpleDateFormat时间格式转换:

狗哥敢保证,100%的小伙伴都用过SimpleDateFormat来格式化时间,一般我们会封装一个工具类,下面这个例子,用来打印 1 到 1000 秒的格式化时间。

public class ThreadLocalDemo {
    //创建一个固定大小的线程池
    public static ExecutorService executorService = Executors.newFixedThreadPool(5);
    
    public static void main(String[] args) {

        for (int i = 0; i <= 1000; i++) {
            int time = i ;
            executorService.submit(new Runnable() {
                @Override
                public void run() {
                    //调用时间类静态方法
                    String formatTime = TimeUtil.getSecond(time);
                    System.out.println(formatTime);
                }
            });
        }
        executorService.shutdown(); 
    }
}

//时间工具类
class TimeUtil {
    static SimpleDateFormat sdf = new SimpleDateFormat("YYYY-MM-DD HH:mm:ss");

    public static String getSecond(int count){
        Date date = new Date(1000*count);
        return sdf.format(date);
    }
}

submit:添加线程任务;shutdown:停止线程池;

线程池这里先进行简单理解,就是始终维护几个线程保持运行,等到有任务到来时会立即处理,若任务太多来不及处理时,就会将其塞入队列,等到正在执行的任务结束后,再继续执行。

这时候我们会发现诡异的一幕,time变量明明是0-1000的自然数,并且不会出现重复数字,这里为什么会打印出相同的格式化结果呢。是不是想起以前写过的那些方法,顿感脊背发凉呢。

《蹲坑也能进大厂》多线程系列-ThreadLocal精讲(基础+源码)

出现这种情况的原因,是因为所有的线程都共用同一个simpleDateFormat对象,发生了线程安全问题,聪明的小伙伴肯定可以想到,我们可以用synchronized来锁住关键代码,不就可以保证结果线程安全了嘛。

public static String getSecond(int count){
    Date date = new Date(1000*count);
    String result = null;
    synchronized(ThreadLocalDemo.class){
        result = sdf.format(date);
    }
    return result;
}

《蹲坑也能进大厂》多线程系列-ThreadLocal精讲(基础+源码)

这样是能够实现我们的目的,结果中也不会出现意外了,但是这样做会导致同一时刻只能有一个线程执行时间格式化(执行串行化),严重影响到程序的性能,在高并发情况下坚决不能忍。

这时候我们的主角ThreadLocal就要闪亮登场了,这里直接看代码,main方法不变,只修改工具类。

class TimeUtil {
    public static String getSecond(int count){
        Date date = new Date(1000*count);
        //使用get获取 SimpleDateFormat
        SimpleDateFormat sdf =  ThreadLocalUtils.simpleDateFormatThreadLocal.get();
        return sdf.format(date);
    }
}

//创建 ThreadLocal
class ThreadLocalUtils {
   public static ThreadLocal<SimpleDateFormat> simpleDateFormatThreadLocal = new 			ThreadLocal<SimpleDateFormat>(){
       @Override
       protected SimpleDateFormat initialValue() {
           return new SimpleDateFormat("YYYY-MM-DD HH:mm:ss");
       }
   };
}

这时候无论怎么执行,都不会出现相同的结果,说明用ThreaLocal创建的对象能够保证线程线程。

2) 避免一些参数传递

昨天618不知道大家有没有剁手,反正我是无手可剁了,只想好好活着。这里我们思考一个问题,在你下单时,后台程序是怎么处理的呢?事实上,后台程序需要处理包括用户信息查询、优惠券查询、收货地址查询、消息通知等等在内的很多流程。因为每一个步骤都可能会用到用户信息,如果把用户信息当做参数层层传递,这样会导致代码耦合性较高且十分臃肿,非常不利于维护。

有些小伙伴可能会想到,我就不用你的ThreadLocal,我写一个静态的map集合存储,不就可以保存了吗?

《蹲坑也能进大厂》多线程系列-ThreadLocal精讲(基础+源码)

在多线程访问同一个变量的情况下,我们知道这会出现线程安全问题,如果使用线程安全类型的集合(如ConCurrentHashMap)或者直接加锁,都会影响程序的执行性能,和上面使用synchronized代码块修饰导致的性能问题是一样的。

因此我们可以总结一下:在线程的生命周期内,使用ThreadLocal的set()方法可以存储该线程的私有变量,并且在需要该变量时通过get() 进行获取。该变量在不同线程中内容是独立的,这样在不损耗性能的情况下,避免了参数多级传递的麻烦。

public class ThreadLocalDemo2 {
    public static ExecutorService executorService = Executors.newFixedThreadPool(10);

    public static void main(String[] args) {
        User user = new User("花Gie");
        ThreadLocalInfo.userThreadLocal.set(user);
        //1.调用获取地址方法
        new AddressService().getAddress();
    }
}
class AddressService{
    public void getAddress(){
        User user = ThreadLocalInfo.userThreadLocal.get();
        System.out.println("根据用户信息"+user.getUserName()+"获取用户地址");
        //2.调用优惠券方法
        new TicketService().getTicket();
    }
}

class TicketService{
    public void getTicket(){
        User user = ThreadLocalInfo.userThreadLocal.get();
        System.out.println("根据用户信息"+user.getUserName()+"获取用户优惠券");
        //3.调用发送消息
        new MessageService().sendMessage();
    }
}
class MessageService{
    public void sendMessage(){
        User user = ThreadLocalInfo.userThreadLocal.get();
        System.out.println("根据用户"+user.getUserName()+"发送消息");
    }
}

class User {
    String userName;

    public User(String userName) {
        this.userName = userName;
    }

    public String getUserName() {
        return userName;
    }
}
//创建ThreadLocal变量
class ThreadLocalInfo {
   public static ThreadLocal<User> userThreadLocal = new ThreadLocal<>();
}

代码的讲解方式真的香,清晰明了,上述代码在获取地址、获取优惠券、发送消息的三个步骤中,我们并没有一层层的传递user对象,但是都能获取到user的对象内容,即使后续需求或流程有调整,我们都可以轻松应对。

《蹲坑也能进大厂》多线程系列-ThreadLocal精讲(基础+源码)

我:狗哥狗哥,我现在知道用法和作用了,那他的实现原理可以说一下吗?

好的呀,先来看下这张图,大致了解一下这ThreadThreadLocalThreadLocalMap三者的关系。

《蹲坑也能进大厂》多线程系列-ThreadLocal精讲(基础+源码)

从图中可以清楚的看到,每一个Thread都会拥有一个ThreadLocalMap对象,而每一个ThreadLocalMap又包含多个ThreadLocal

我:这是你自己画的图...我怎么知道是不是胡扯的呢!

花Gie几天不见学聪明了啊,那我们就看一下源码呗。ThreadLocal有四个比较重要的方法:

public T get() {}
public void set(T value) {}
protected T initialValue() {}

首先看一下第一种场景中我们重写过的 initialValue()方法:

protected T initialValue() {
    return null;
}

非常明显,如果我们不主动重写 initialValue()方法的话,它会返回一个null值。

接下来看下set方法:

public void set(T value) {
    //1.获取当前线程
    Thread t = Thread.currentThread();
    //2.获取ThreadLocalMap对象
    ThreadLocalMap map = getMap(t);
    //3.如果map存在,就会将当前ThreadLocal对象作为key存储到map中
    //this:就是当前的ThreadLocal
    if (map != null)
        map.set(this, value);
    else
        //4.map不存在时,则创建
        createMap(t, value);
}

上面第二步有一个ThreadLocalMap,这个是什么呢,其实在Thread类中我们可以找到结果,他是Thread中的一个内部类。这里看下关键代码,ThreadLocalMap是用键值数组Entry[] table,来存储数据,Entry就可以类比为一个map,其中键是指ThreadLocal; 值则是需要保存的内容,如SimpleDateFormat、user。

ThreadLocalMap就是上图中灰色部分

static class ThreadLocalMap {
    static class Entry extends WeakReference<ThreadLocal<?>> {
        /** The value associated with this ThreadLocal. */
        Object value;

        Entry(ThreadLocal<?> k, Object v) {
            super(k);
            value = v;
        }
    }
      private Entry[] table;
    ....省略
}

然后看下getMap的内容,他会返回当前线程的threadLocals对象,因此在没有重写initialValue()进行初始化时,首次调用set()方法getMap会返回一个null,然后对其进行createMap操作。

ThreadLocalMap getMap(Thread t) {
    return t.threadLocals;
}
// Thread.java 
// threadLocals默认为null
ThreadLocal.ThreadLocalMap threadLocals = null;

createMap操作也是比较简单的,就是用来新建一个ThreadLocalMap对象赋值给当前线程的threadLocals变量。

void createMap(Thread t, T firstValue) {
    t.threadLocals = new ThreadLocalMap(this, firstValue);
}

看完上面的源码,那get()方法就非常容易理解了。首先看第3步代码,如果之前已经调用过set()方法(threadLocals对象没有被初始化),就会将当前ThreadLocal对象作为key,获取threadLocals中事先保存的value值。

public T get() {
    //1.获取当前线程
    Thread t = Thread.currentThread();
    //2.获取当前线程的threadLocalMap
    ThreadLocalMap map = getMap(t);
    //3.如果ThreadLocal已经初始化
    if (map != null) {
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    //4.ThreadLocal没有初始化,则调用initialValue()进行初始化操作
    return setInitialValue();
}

但是最后一句是做什么的呢,其实这里是用到了延迟加载的方式,我们在重写initialValue()方法时,它并没有立即进行初始化,而是等到第一次查询的时候,才执行setInitialValue()方法进行初始化。

private T setInitialValue() {
    //重写的initialValue方法
    T value = initialValue();
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
    return value;
}

看到这里,是不是基本搞清了图中Thread、ThreadLocal、ThreadLocalMap三者的关系及流程呢。

我:虽然很啰嗦,但是真的很详细呀!

这里想说一下,每次说这么多,我也是手酸、嘴也累啊,但是又十分担心如果忽略了某些细节,很多小伙伴可能就听不懂了,所以比较流弊的小伙伴可以跳着看,忽略一些细节,如果是新手小伙伴,看起来也是更加轻松,更加容易理解。

我:狗子用心了,花Gie在此给你点个赞。那ThreadLocal既然这么多好处,它有什么缺陷吗?

凡是都有两面性,ThreadLocal肯定也有些问题需要注意,就是内存泄漏问题

《蹲坑也能进大厂》多线程系列-ThreadLocal精讲(基础+源码)

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

如上述代码,value = v 表示我们设置到ThreadLocal中的值和ThreadLocalMap是强引用,再结合上图我们可以得到内存泄露的原因:是由于ThreadLocalMap的生命周期跟Thread一样长,如果线程不销毁,那ThreadLocal就会一直存活,如果没有手动删除对应key就会导致内存泄漏。

比如在线程池这种场景下,因为线程始终存活,所以此时使用ThreadLocal的话,就会导致内存泄漏。想要避免内存泄露就要手动remove()掉

我:狗儿你这修炼两天的效果,我都惊呆了,给小伙伴们总结一下吧。

ThreadLocal总结起来有以下几点:

  • 在该线程的生命周期中,可以轻松获取该对象;
  1. 作用:

    • 每个线程可以拥有自己独立的对象,与其他线程实现隔离;
    • 在该线程的生命周期中,可以轻松获取该对象;
  2. 优点:

    • 不需要加锁就能实现线程安全
    • 高效利用内存,节省开销
    • 无需层层传参,实现代码解耦
  3. 场景选择:

    • 对于工具类这种,所有线程共用一个实例时,在创建ThreadLocal变量时就将其初始化;
    • 对于不同线程拥有不同对象时,灵活使用set()方法进行设置。
  4. 原理总结:

    • ThreadLocalMap是Thread的内部类,并且每个Thread维护一个ThreadLocalMap的引用
    • initialValue()和set()设置键值对本质相同,本质都是调用map.set(this,value)
    • ThreadLocal本身并不存储值,它只是作为一个key从ThreadLocalMap获取value。

总结

用ThreadLocal的目的并不是为了解决并发或者共享变量的问题,而是为了能够在当前线程中有属于自己的变量,实现线程的数据隔离。

最后小编在学习过程中整理了一些学习资料,可以分享给做软件测试工程师的朋友们,相互交流学习,需要的可以加入我的学习交流群 323432957 或加微dingyu-002即可免费获取Python自动化测开及Java自动化测开学习资料(里面有功能测试、性能测试、python自动化、java自动化、测试开发、接口测试、APP测试等多个知识点的架构资料)

上一篇:并发编程-ThreadLocal&ForkJoinPool(使用以及原理分析)


下一篇:单例模式在多线程中的使用情况