Java并发:ThreadLocal的简单介绍

【Java并发编程】ThreadLocal由浅入深说 不要停留在用,一文带你了解ThreadLocal底层 阅读详情

前言

前面在线程的安全性中介绍过全局变量(成员变量)和局部变量(方法或代码块内的变量),前者在多线程中是不安全的,需要加锁等机制来确保安全,后者是线程安全的,但是多个方法之间无法共享

而今天的主角ThreadLocal,就填补了全局变量和局部变量之间的空白

简介

ThreadLocal的作用主要有二:

  1. 线程之间的数据隔离:为每个线程创建一个副本,线程之间无法相互访问

  2. 传参的简化:为每个线程创建的副本,在单个线程内是全局可见的,在多个方法之间不需要传来传去

其实上面的两个作用,归根到底都是副本的功劳,即每个线程单独创建一个副本,就产生了上面的效果

ThreadLocal直译为线程本地变量,巧妙地融合了全局变量和局部变量两者的优点

下面我们分别举两个例子来说明它的作用

目录

  1. 例子 - 数据隔离
  2. 例子 - 传参优化
  3. 内部原理

正文

我们在接触一个新东西时,首先应该是先用起来,然后再去探究内部原理

Thread Local的使用还是比较简单的,类似Map,各种put/get

它的核心方法如下:

  • public void set(T value):保存当前副本到ThreadLocal中,每个线程单独存放
  • public T get():取出刚才保存的副本,每个线程只会取出自己的副本
  • protected T initialValue():初始化副本,作用和set一样,不过initialValue会自动执行,如果get()为空
  • public void remove():删除刚才保存的副本

1. 例子 - 数据隔离

这里我们用SimpleDateFormat举例,因为这个类是线程不安全的(后面有空再单独开篇),如果不做隔离,会有各种各样的并发问题

我们先来看下线程不安全的例子,代码如下:

public class ThreadLocalDemo {

    // 线程不安全:在多个线程中执行时,有可能解析出错
    private SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
    public void parse(String dateString){
        try {
            System.out.println(simpleDateFormat.parse(dateString));
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(10);
        ThreadLocalDemo demo = new ThreadLocalDemo();
        for (int i = 0; i < 30; i++) {
            service.execute(()->{
                demo.parse("2020-01-01");
            });
        }
    }
}

多次运行,可能会出现下面的报错:

Exception in thread "pool-1-thread-4" java.lang.NumberFormatException: empty String

关于SimpleDateFormat的不安全问题,在源码注释里有提到,如下:

Date formats are not synchronized. It is recommended to create separate format instances for each thread. If multiple threads access a format concurrently, it must be synchronized externally.

意思就是建议多线程使用时,要么每个线程单独创建,要么加锁

下面我们分别用加锁和单独创建来解决

线程安全的例子:加锁

public class ThreadLocalDemo {

    // 线程安全1:加内置锁
    private SimpleDateFormat simpleDateFormatSync = new SimpleDateFormat("yyyy-MM-dd");
    public void parse1(String dateString){
        try {
           synchronized (simpleDateFormatSync){
               System.out.println(simpleDateFormatSync.parse(dateString));
           }
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(10);
        ThreadLocalDemo demo = new ThreadLocalDemo();
        for (int i = 0; i < 30; i++) {
            service.execute(()->{
                demo.parse1("2020-01-01");
            });
        }
    }
}

线程安全的例子:通过ThreadLocal为每个线程创建一个副本

public class ThreadLocalDemo {

    // 线程安全2:用ThreadLocal创建对象副本,做数据隔离
    // 下面这个代码可以简化,通过 withInitialValue
    private static ThreadLocal<SimpleDateFormat> threadLocal = new ThreadLocal<SimpleDateFormat>(){
        // 初始化方法,每个线程只执行一次;比如线程池有10个线程,那么不管运行多少次,总的SimpleDateFormat副本只有10个
        @Override
        protected SimpleDateFormat initialValue() {
            // 这里会输出10次,分别是每个线程的id
            System.out.println(Thread.currentThread().getId());
            return new SimpleDateFormat("yyyy-MM-dd");
        }
    };
    public void parse2(String dateString){
        try {
            System.out.println(threadLocal.get().parse(dateString));
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(10);
        ThreadLocalDemo demo = new ThreadLocalDemo();
        for (int i = 0; i < 30; i++) {
            service.execute(()->{
                demo.parse2("2020-01-01");
            });
        }
    }
}

有的朋友可能会有疑问,这个例子为啥不直接创建局部变量呢?

这是因为如果创建局部变量,那么调用一次就会创建一个SimpleDateFormat,性能会比较低

而通过ThreadLocal为每个线程创建一个副本,那么基于这个线程的后续所有操作,都是访问这个副本,无需再次创建

2. 例子 - 传参优化

有时候,我们需要在多个方法之间进行传参(比如用户信息),此时就面临一个问题:

  • 如果将要传递的参数设置为全局变量,那么线程不安全
  • 如果将要传递的参数设置为局部变量,那么传参会很麻烦

这时就需要用到ThreadLocal了,正如开篇讲得,它的作用就是融合全局和局部的优点,使得线程也安全,传参也方便

下面是例子:

public class ThreadLocalDemo2 {

    // 参数传递,程序繁琐
    public void fun1(int age){
        System.out.println(age);
        fun2(age);
    }
    private void fun2(int age){
        System.out.println(age);
        fun3(age);
    }
    private void fun3(int age){
        System.out.println(age);
    }

    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(10);
        ThreadLocalDemo2 demo = new ThreadLocalDemo2();
        for (int i = 0; i < 30; i++) {
            final int j = i;
            service.execute(()->{
                demo.fun1(j);
            });
        }
    }
}

这段代码可能没有实际意义,但是意思应该到了,就是表达传递参数的繁琐性

下面我们看下用ThreadLocal来解决这个问题

public class ThreadLocalDemo2 {

    // 简化,ThreadLocal当全局变量来使用
    private static ThreadLocal<Integer> threadLocal = new ThreadLocal<Integer>();
    public void fun11(){
        System.out.println(threadLocal.get());
        fun22();
    }
    private void fun22(){
        System.out.println(threadLocal.get());
        fun33();
    }
    private void fun33(){
        int age = threadLocal.get();
        System.out.println(age);
    }

    public static void main(String[] args) {
        ExecutorService service = Executors.newFixedThreadPool(10);
        ThreadLocalDemo2 demo = new ThreadLocalDemo2();
        for (int i = 0; i < 30; i++) {
            final int j = i;
            service.execute(()->{
                try{
                    threadLocal.set(j);
                    demo.fun11();
                }finally {
                    threadLocal.remove();
                }
            });
        }
    }
}

可以看到,这里我们不再把age参数传来传去,而是为每个线程创建一个副本age

这样所有方法都可以访问到副本,同时也保证了线程安全

不过要注意的是,这次的使用和上次不同,这次多了remove方法,它的作用就是删除上面set的副本,这个下面再介绍

3. 内部原理

先来说说它是怎么做到数据隔离的

我们先来看下set方法:

public void set(T value) {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
}

可以看到,值是存在map里的(key是ThreadLocal对象,value就是为线程单独创建的副本)

而这个map是怎么来的呢?再来看下面的代码

ThreadLocalMap getMap(Thread t) {
    return t.threadLocals;
}

可以看到,最终还是回到了Thread里面,这就是为啥线程之间实现了隔离,而线程内部实现了共享(因为是线程内的属性,只有当前线程可见)

我们再看下get()方法,如下:

public T get() {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null) {
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null) {
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    return setInitialValue();
}

可以看到,先找到当前线程内的map,然后再根据key取出value

最后一行的setInitialValue,就是在get为空时,重新执行的初始化动作

为什么要用ThreadLocal作为key,而不是线程id呢

是为了存储多个变量

如果用了线程id作为key,那么map里一个线程只能存放一个变量

而用了ThreadLocal作为key,那么可以一个线程存放多个变量(通过创建多个ThreadLocal)

如下所示:

private static ThreadLocal<Integer> threadLocal1 = new ThreadLocal<Integer>();
private static ThreadLocal<Integer> threadLocal2 = new ThreadLocal<Integer>();

public void test(){
    threadLocal1.set(1);
    threadLocal2.set(2);
    System.out.println(threadLocal1.get());
    System.out.println(threadLocal2.get());
}

再来说下它的内存泄漏问题

我们先来看下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;
        }
    }
}

可以看到,内部节点Entry继承了弱引用(在垃圾回收时,如果一个对象只有弱引用,则会被回收),然后在构造函数中通过super(k)将key设置为弱引用

因此在垃圾回收时,如果外部没有指向ThreadLocal的强引用,那么就会直接把key回收掉

此时key=null,而value还在,但是又取不出来,久而久之,就会出现问题

解决办法就是remove,通过在finally中remove,将副本从ThreadLocal中删除,此时key和value都被删除

总结

  1. ThreadLocal直译为线程本地变量,它的作用就是通过为每个线程单独创建一个副本,来保证线程间的数据隔离和简化方法间的传参
  2. 数据隔离的本质:Thread内部持有ThreadLocalMap对象,创建的副本都是存在这里,所以每个线程之间就实现了隔离
  3. 内存泄漏的问题:因为ThreadLocalMap中的key是弱引用,所以垃圾回收时,如果key指向的对象没有强引用,那么就会被回收,此时value还存在,但是取不出来,时间长了,就有问题(当然如果线程退出,那value还是会被回收)
  4. 使用场景:面试等场合

后记

其实这里没有很深入地去解析源码部分知识,主要是精力和能力有限,后面再慢慢深入吧

最后


作为过来人,小编是整理了很多进阶架构视频资料、面试文档以及PDF的学习资料,针对上面一套系统大纲小编也有对应的相关进阶架构视频资料,如’确定好自己未来的道路或者想学习提升自己技术栈、技术知识的小伙伴们可以点击这里来获取免费学习资料提升自己(全套面试文档、PDF、进阶架构视频)

55、Mac OS X 10.2 安装、设置、卸载及故障排除全攻略 本博客全面解析了 Mac OS X 10.2 的安装、设置、卸载及故障排除方法。内容涵盖四种安装方式的适用场景及操作步骤、设置助手的详细配置流程、卸载注意事项与恢复建议,以及常见问题和进阶故障的解决办法。通过图文并茂的形式,帮助用户快速掌握 Mac OS X 10.2 的基础与高级操作,是使用该操作系统的实用指南。 阅读详情

相关推荐

无人机散热系统设计:从材料选择到智能调控的全面解析

本文全面解析无人机散热系统设计,从材料选择到智能调控,探讨了导热界面材料、轻量化散热结构和智能调控算法的应用。通过实战案例,展示了如何在极端环境下优化散热性能,提升无人机的工作效率和可靠性。

weixin_42567279的博客 430

ThreadLocal源码分析:(二)get()方法

在ThreadLocal的get(),set()的时候都会清除线程ThreadLocalMap里所有key为null的value。 而ThreadLocal的remove()方法会先将Entry中对key的弱引用断开,设置为null,然后再清除对应的key为null的value。 本文分析get方法 ThreadLocal类的get方法 public T get() { Thr...

noodleprince的博客 6494

深度解读扫地机器人的导航原理

科技改变生活,不可否认科技的进步的确为我们的生活带来许多便捷,以智能家电为例,智能电饭煲、智能洗碗机、智能扫地机等产品已逐渐成为家庭的一分子,其中以扫地机表现最为抢眼。能做到智能规划清扫,收割了不少家庭主妇及科技爱好者的芳心。但扫地机并非一开始就这么智能,最初的扫地机只能做到随机式清扫,会频繁出现碰撞现象。 近年来,通过业界的不断努力,目前,扫地机器人已告别乱碰乱撞现象,能做到自主路径...

qq_38403231的博客 6506

ThreadLocal关键字解析

ThreadLocal关键字解析ThreadLocal脑图ThreadLocal的数据结构 ThreadLocal脑图 ThreadLocal的数据结构

weixin_44339676的博客 739

数据分析—用户行为数据分析

一般价值用户(R高F高M低):用户处于购买活跃期,感兴趣的商品多,购买次数少 → 针对该部分客户,目的就是要让他们购买,所以可以和运营部门沟通,降低利润,给出有力折扣促进购买,进而转为重要价值用户。重要价值用户(R高F高M高)维护:用户处于购买活跃期,感兴趣的商品多,购买次数也多 → 针对兴趣产品,保持一定频率的触达,持续维护。

m0_74091312的博客 1421

别再手动改文献了!手把手教你定制Mendeley的GB/T 7714-2005引用格式(附常见问题修复)

本文详细指导如何定制Mendeley的GB/T 7714-2005引用格式,解决科研文献管理中的常见问题。通过深度解析Mendeley样式编辑器,精准控制作者显示规则、出版社信息精简及期刊页码处理,实现参考文献一键合规。附常见问题修复和实战调试方法,大幅提升学术写作效率。

weixin_26833503的博客 375

Java——多线程高并发系列之ThreadLocal的使用

Java——多线程高并发系列之ThreadLocal的使用

贝尔摩德苦艾酒 7171

通过Power Platform自定义D365 CE 业务需求 - 4. 使用Power Automate

Power Automate构建块Power Automate中的连接器流的类型和用途流中的动态值和表达式使用变量、循环和条件在Power Automate中处理审批业务场景、用例和实现Power Virtual Agent的概念Power Virtual Agent的构建块配置Power Virtual Agent示例在公共网站/门户中部署Power Virtual Agent业务场景、用例和实现。

Martin-Mei的博客 563

Java 并发编程:ThreadLocal 简单介绍

Java 并发编程:ThreadLocal 简单介绍 1. ThreadLocal 是如何保证线程安全的? 简单来说,造成线程不安全的原因是多个线程同时去更新共享数据,处理共享数据常用的方法就是加锁,通过加锁的方式来控制线程对共享数据的访问,例如乐观锁和悲观锁。 ThreadLocal 保证线程安全的方式是为每个线程提供一个独立的变量副本来解决冲突问题,每个线程更改的都是自己的变量副本,从根本上解决解决问题。 2. ThreadLocal 使用场景 ThreadLocal 对于每个线程都需要拥有自己

qq_43270409的博客 197

SAP_SD模块信用管理-最早未清项判断逾期

在 SAP SD 模块的信用管理(Credit Management) 中,系统可以通过 最早未清项(Oldest Open Item) 来判断客户是否存在逾期,从而影响订单的信用检查结果。例如: 定义最大未清项目%为1%,未清天数为1天,即允许客户“逾期1天的未清应收帐款/该客户的应收帐款余额”最大比例为1%,若超过1%则将被信用冻结。的信用检查功能,用于判断客户是否有账龄过长的未清款项,并据此决定是否允许新的销售订单继续处理。然后在查看客户的信贷信息可以看到,最早的未清信息显示在系统中。

我小时候很黑的博客 867

AI处理器组合

编号0-3的处理器处于同一个链路中,编号4-7的处理器处于另外一个链路中,不通链路中的处理器不能通信,如下图所示。- 如果申请处理器个数为1,则选择同一链路,剩余可用的处理器数量为1个的最佳,其次是剩余3个的为次佳,然后是剩余2个,最后是剩余4个。输出为组合列表,当array=[0, 1, 4, 5, 6, 7] ,num=1时,输出为[[0], [1]]- 如果申请处理器个数为2,则选择同一链路剩余可用的处理器数量2个的为最佳,其次是剩余4个,最后是剩余3个。任务申请1个处理器。

面试高手的博客 1万+

Java并发:ThreadLocal详解

前言 ThreadLocal的作用是提供线程内的局部变量,这种变量在多线程环境下访问时能够保证各个线程里变量的独立性。ThreadLocal无论在项目开发还是面试中都会经常碰到,本文就ThreadLocal的使用、主要方法源码详解、内存泄漏问题展开讨论。 1.基本使用 package com.joonwhee.imp; /** * demo * @author joonwhee...

程序员囧辉 1万+

YOLOv9改进策略【注意力机制篇】| 添加SE、CBAM、ECA、CA、Swin Transformer等注意力和多头注意力机制

这篇文章带来一个经典注意力模块的汇总,虽然有些模块已经发布很久了,但后续的注意力模块也都是在此基础之上进行改进的,对于初学者来说还是有必要去学习了解一下,以加深对模块,模型的理解。

Limiiiing的博客 2895

并发编程——ThreadLocal篇

ThreadLocal类翻译过来叫做“线程本地变量”类或者“线程局部变量”类。顾名思义,在多个线程对ThreadLocal类型的对象中的变量进行访问时,其每个线程只能去访问自己的那个独立变量,而不会出现一个线程读取到另一个线程修改变量后的值,这使得在多线程并发执行的场景中做到了线程安全。

2202_75359757的博客 2256

android 蓝牙通讯demo

android 下蓝牙通讯demo,实现了发现蓝牙,使能蓝牙,通过蓝牙发送消息。

计算机控制技术及应用

《计算机控制技术及应用》通过总结作者的科研成果和吸收国内外的先进理论、方法和技术,以计算机控制系统的网络化、开放化、智能化和集成化发展趋势为主线索,主要介绍计算机控制系统的基本概念和计算机控制系统的典型形式,计算机控制系统的数学描述与基本分析方法,以及数字PID控制器、最少拍控制系统、达林算法、状态变量设计法等设计方法及其各种改进算法。重点突出计算机控制系统输入输出通道接口的设计方法和典型控制系统的设计案例与实现方法等。

Java并发——ThreadLocal总结

并发问题,有时候,可以用ThreadLocal方式来避免。ThreadLocal,顾名思义,就是线程自己的,独享的,就像线程栈是线程独享的一样。

BASK2311的博客 985

VC中sqlite的使用

在VC中对sqlite的使用,实现数据库大批数据的快速插入,读取数据库中的数据在ListCtrl中显示

Java并发工具之ThreadLocal

ThreadLocal 字面意思是本地线程,其实更准确来说是线程局部变量,线程类 Thread 有个变量叫做 threadLocals,其类型就是ThreadLocal.ThreadLocalMap 类型,他其实不是一个 Map 类型,但可以暂时理解它是一个Map,键为 ThreadLocal 对象,值就是要存入的value。

Qynwang的博客 6544

华为的C语言编程规范.pdf

华为技术有限公司内部技术规范。本规范制定了编写C语言程序的基本原则、规则和建议。从代码的清晰、简洁、可测试、安全、程序效率、可移植各个方面对C语言编程作出了具体指导。

Java并发编程——ThreadLocal

ThreadLocal详解

m0_62909831的博客 1244

Java并发学习总结:ThreadLocal

Java 并发 ThreadLocal

1144

【Java并发】ThreadLocal

ThreadLocal是java.lang下面的一个类,是用来解决java多线程程序中并发问题的一种途径;通过为每一个线程创建一份共享变量的副本来保证各个线程之间的变量的访问和修改互相不影响;ThreadLocal存放的值是线程内共享的,线程间互斥的,主要用于线程内共享一些数据,避免通过参数来传递,这样处理后,能够优雅的解决一些实际问题。

xueping_wu的博客 789

深入剖析 Java 并发工具 ThreadLocal

在多线程编程中,共享数据的访问与修改是一个常见的问题。为了解决这个问题,Java提供了ThreadLocal类,它允许我们在每个线程中创建一个独立的变量副本,使得每个线程都可以独立地访问和修改自己的副本,而不会相互干扰。本文将深入探讨Java中ThreadLocal的详细作用,以及需要注意的事项,并通过示例代码进行解析。

鹏鹏2077 4626

Java并发之ThreadLocal

ThreadLocal 是一个非常有用的工具类,它可以用于保存线程中的变量,这样在同一个线程中的任何地方都可以获取到线程中的变量。但是,ThreadLocal 也是一个非常容易被误用的工具类,如果没有使用好,就可能会造成内存泄漏的问题。ThreadLocalMap 是 ThreadLocal 的核心,它是一个以 ThreadLocal 实例为 key,任意对象为 value 的哈希表。

heromps的博客 1154

java并发之ThreadLocal

ThreadLocal的思考: 描述: 方法1:传入秒数,new一个SimpleDataFormat对象,返回时间字符串 方法2:生成两个线程,每个线程都去调用方法1来打印不同秒数的时间 结果:运行正常 进一步思考:要是1000个线程呢?用线程池,生成10线程 进一步思考:在方法1中,每次调用都会new一个SimpleDataFormat对象,浪费开销 解决方法:将S...

简单点,编程的方式简单点 270

Java并发系列番外篇:ThreadLocal原理其实很简单

多线程并发是Java语言中非常重要的一块内容,同时,也是Java基础的一个难点。说它重要是因为多线程是日常开发中频繁用到的知识,说它难是因为多线程并发涉及到的知识点非常之多,想要完全掌握Java的并发相关知识并非易事。也正因此,Java并发成了Java面试中最高频的知识点之一。本系列文章将从Java内存模型、volatile关键字、synchronized关键字、ReetrantLock、Atomic并发类以及线程池等方面来系统的认识Java的并发知识。通过本系列文章的学习你将深入理解volatile关键字

smily的博客 322

ThreadLocal实战:Java并发编程中的利器

要点 | 描述 || ThreadLocal | 用于线程隔离的利器,适用于高并发场景 || 线程安全 | 通过为每个线程绑定变量副本实现线程之间的数据隔离 || 性能 | 高吞吐量、低延迟 |ThreadLocal是Java并发编程中的利器,在高并发场景下,可以有效解决线程安全问题。随着技术的不断发展,ThreadLocal将在更多场景中得到应用。未来,我们期待看到更多关于ThreadLocal的创新和突破。

南客先生的博客 871

Java并发——ThreadLocal

ThreadLocal用于解决多线程访问共享资源的安全性问题,常用于将状态信息(SessionId,用户ID)与当前线程关联

Uncommon的博客 1604
上一篇: 程序员,请你不要在坑程序员了
下一篇: 列举出常见的Java面试题,我靠这个在春招拿到了阿里的offer
奇迹摘星w
博客等级 码龄6年 1844粉丝 189原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值