一文理解ThreadLocal

最新推荐文章于 2024-01-05 17:52:26 发布
最新推荐文章于 2024-01-05 17:52:26 发布
阅读量519 收藏 6
点赞数 5
文章标签： java spring jvm 内存泄漏 spark
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/y277an/article/details/118212488
版权

本文讲解ThreadLocal、InheritableThreadLocal与TransmittableThreadLocal。

有关本文的实验代码，可以查看文末补充：“比较一下ThreadLocal、InheritableThreadLocal、TransmittableThreadLocal在线程池复用线程的情况下的执行情况”。

ThreadLocal

ThreadLocal的使用场景

  1. 分布式跟踪系统

  2. 日志收集记录系统上下文

  3. Session级Cache

  4. 应用容器或上层框架跨应用代码给下层SDK传递信息

举例：

  1. Spring的事务管理，用ThreadLocal存储Connection，从而各个DAO可以获取同一Connection，可以进行事务回滚，提交等操作。

  2. 某些业务场景下，需要强制读主库来保证数据的一致性。在Sharding-JDBC中使用了ThreadLocal来存储相关配置信息，实现优雅的数据传递。

  3. Spring Cloud Zuul用过滤器可以实现权限认证，日志记录，限流等功能，多个过滤器之间透传数据，底层使用了ThreadLocal。

  4. 在整个链路的日志中输出当前登录的用户ID，首先就得在拦截器获取过滤器中获取用户。ID，然后将用户ID进行存储到slf4j的MDC对象（底层使用ThreadLocal），然后进行链路传递打印日志。

ThreadLocal的结构

  1. ThreadLocal的get()、set()方法，实际操作的都是Thread.currentThread()，即当前线程的threadLocals变量。

  2. threadLocals变量包含了一个map成员变量（ThreadLocalMap）。

  3. ThreadLocalMap的key为当前ThreadLocal, value为set的值。

相同的key在不同的散列表中的值必然是独立的，每个线程都是在各自的散列表中执行操作，如下图所示：

ThreadLocal的set方法：

public void set(T value) {
    //currentThread是个native方法，会返回对当前执行线程对象的引用。
    Thread t = Thread.currentThread();
    //getMap 返回线程自身的threadLocals
    ThreadLocalMap map = getMap(t);
    if (map != null) {
        //把value set到线程自身的ThreadLocalMap中了
        map.set(this, value);
    } else {
        //线程自身的ThreadLocalMap未初始化，则先初始化，再set
        createMap(t, value);
    }
}
ThreadLocalMap getMap(Thread t) {
    return t.threadLocals;
}

ThreadLocal.ThreadLocalMap threadLocals = null;

ThreadLocal在set的时候，没有进行相应的深拷贝，所以ThreadLocal要想做线程隔离，必须是基本类型或者是Runable实现类的局部变量。

ThreadLocal造成内存泄漏

ThreadLocalMap内部Entry：

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

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

从代码中看到，Entry继承了WeakReference，并将ThreadLocal设置为了WeakReference，value设置为强引用。也就是：当没有强引用指向ThreadLocal变量时，它可被回收。

内存泄漏风险：ThreadLocalMap维护ThreadLocal变量与具体实例的映射，当ThreadLocal变量被回收后（变为null），无法路由到ThreadLocalMap。而该Entry还是在ThreadLocalMap中，从而这些无法清理的Entry，会造成内存泄漏。

所以，在使用ThreadLocal的时候，会话结束前务必使用ThreadLocal.remove方法（remove方法会将Entry的value及Entry自身设置为null并进行清理）。

ThreadLocal的最佳实践

  1. ThreadLocal使用时必须显式地调用remove方法来避免内存泄漏。

  2. ThreadLocal对象建议使用static修饰。这样做的好处是可以避免重复创建对象所导致的浪费（类第一次被使用时装载，只分配一块存储空间）。坏处是正好形成内存泄漏所需的条件(延长了ThreadLocal的生命周期，因此需要remove方法兜底)。

  3. 注释说明使用场景。

  4. 对性能有极致要求可以参考开源框架优化后的类，比如Netty的FastThreadLocal、Dubbo的InternalThreadLocal等。

InheritableThreadLocal

在全链路跟踪框架中，Trace信息的传递功能是基于ThreadLocal的。但实际业务中可能会使用异步调用，这样就会丢失Trace信息，破坏了链路的完整性。

此时可以使用JDK实现的InheritableThreadLocal，但它只支持父子线程间传递信息（例如：paramstream、new Thread等）。

Thread内部为InheritableThreadLocal开辟了一个单独的ThreadLocalMap（与ThreadLocal并列的成员变量）。在父线程创建一个子线程的时候，会检查这个ThreadLocalMap是否为空，不为空则会浅拷贝给子线程的ThreadLocalMap。

从类的继承层次来看，InheritableThreadLocal只是在ThreadLocal的get、set、remove流程中，重写了getMap、createMap方法，整体流程与ThreadLocal保持一致。

Thread的init相关逻辑如下：

if (parent.inheritableThreadLocals != null)
    this.inheritableThreadLocals = ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);

需要注意的是拷贝为浅拷贝。

TransmittableThreadLocal

InheritableThreadLocal可以在父线程创建子线程的时候将ThreadLocal中的值传递给子线程，从而完成链路跟踪框架中的上下文传递。

但大部分业务应用都会使用线程池，这种复用线程的池化场景中，线程池中的线程和主线程并不都是父子线程的关系，不能直接使用InheritableThreadLocal。

例如从Tomcat的线程（池化）提交task到业务线程池，就不能直接使用InheritableThreadLocal。

Transmittable ThreadLocal（简称TTL）是阿里开源的库，继承了InheritableThreadLocal，实现线程本地变量在线程池的执行过程中，能正常的访问父线程设置的线程变量。

TransmittableThreadLocal实现原理

InheritableThreadLocal不支持池化线程提交task到业务线程池的根本原因是，父线程创建子线程时，子线程InheritableThreadLocal只会复制一次环境变量。要支持线程池中能访问提交任务线程的本地变量，只需要在线程向线程池提交任务时复制父线程的上下环境，那在线程池中就能够访问到父线程中的本地变量，实现本地环境变量在线程池调用中的透传。

源码见于参考文档1，README有很详细的讲解，核心源码也不难，建议看看。

此外，项目引入TTL的时候，可以使用Java Agent植入修饰代码，修改runnable或者callable类，可以做到对应用代码无侵入（这个在README也有相关讲解）。

补充说明

ThreadLocal、InheritableThreadLocal、TransmittableThreadLocal在线程池复用线程的情况下的执行情况如下：

1.线程局部变量为基础类型

1.1 ThreadLocal

class TransmittableThreadLocalTest1 {
    static ThreadLocal<Integer> threadLocal = new ThreadLocal<>();
    static ExecutorService executorService =
            Executors.newFixedThreadPool(1);

    public static void main(String[] args) throws InterruptedException {
        System.out.println("主线程开启");
        threadLocal.set(1);
        System.out.println("主线程读取本地变量：" + threadLocal.get());

        executorService.submit(() -> {
            System.out.println("子线程读取本地变量：" + threadLocal.get());
        });

        TimeUnit.SECONDS.sleep(1);

        threadLocal.set(2);
        System.out.println("主线程读取本地变量：" + threadLocal.get());

        executorService.submit(() -> {
            //[没有读到了主线程修改后的新值]
            System.out.println("子线程读取本地变量：" + threadLocal.get());
            threadLocal.set(3);
            System.out.println("子线程读取本地变量：" + threadLocal.get());
        });

        TimeUnit.SECONDS.sleep(1);
        //依旧读取的是 2
        System.out.println("主线程读取本地变量：" + threadLocal.get());
    }
}

输出结果为：

主线程开启
主线程读取本地变量：1
子线程读取本地变量：null
主线程读取本地变量：2
子线程读取本地变量：null
子线程读取本地变量：3
主线程读取本地变量：2

1.2 InheritableThreadLocal

class TransmittableThreadLocalTest2 {
    static ThreadLocal<Integer> threadLocal = new InheritableThreadLocal<>();
    static ExecutorService executorService =
            Executors.newFixedThreadPool(1);

    public static void main(String[] args) throws InterruptedException {
        System.out.println("主线程开启");
        threadLocal.set(1);
        System.out.println("主线程读取本地变量：" + threadLocal.get());

        executorService.submit(() -> {
            System.out.println("子线程读取本地变量：" + threadLocal.get());
        });

        TimeUnit.SECONDS.sleep(1);

        threadLocal.set(2);
        System.out.println("主线程读取本地变量：" + threadLocal.get());

        executorService.submit(() -> {
            //[没有读到了主线程修改后的新值]
            System.out.println("子线程读取本地变量：" + threadLocal.get());
            threadLocal.set(3);
            System.out.println("子线程读取本地变量：" + threadLocal.get());
        });

        TimeUnit.SECONDS.sleep(1);
        //依旧读取的是 2
        System.out.println("主线程读取本地变量：" + threadLocal.get());
    }
}

输出结果为：

主线程开启
主线程读取本地变量：1
子线程读取本地变量：1
主线程读取本地变量：2
子线程读取本地变量：1
子线程读取本地变量：3
主线程读取本地变量：2

1.3 TransmittableThreadLocal

class TransmittableThreadLocalTest3 {
    static ThreadLocal<Integer> threadLocal = new TransmittableThreadLocal<>();
    static ExecutorService executorService =
            TtlExecutors.getTtlExecutorService(Executors.newFixedThreadPool(1));

    public static void main(String[] args) throws InterruptedException {
        System.out.println("主线程开启");
        threadLocal.set(1);
        System.out.println("主线程读取本地变量：" + threadLocal.get());

        executorService.submit(() -> {
            System.out.println("子线程读取本地变量：" + threadLocal.get());
        });

        TimeUnit.SECONDS.sleep(1);

        threadLocal.set(2);
        System.out.println("主线程读取本地变量：" + threadLocal.get());

        executorService.submit(() -> {
            //[读到了主线程修改后的新值]
            System.out.println("子线程读取本地变量：" + threadLocal.get());
            threadLocal.set(3);
            System.out.println("子线程读取本地变量：" + threadLocal.get());
        });

        TimeUnit.SECONDS.sleep(1);
        //依旧读取的是 2
        System.out.println("主线程读取本地变量：" + threadLocal.get());
    }
}

输出结果为：

主线程开启
主线程读取本地变量：1
子线程读取本地变量：1
主线程读取本地变量：2
子线程读取本地变量：2
子线程读取本地变量：3
主线程读取本地变量：2

2.线程局部变量为类对象

首先定义一个数据类：

@Data
@AllArgsConstructor
class UserSession{
    String uuid;
    String nickname;
}

2.1 ThreadLocal

class TransmittableThreadLocalTest4 {
    static ThreadLocal<UserSession> threadLocal = new ThreadLocal<>();
    static ExecutorService executorService =
            Executors.newFixedThreadPool(1);

    public static void main(String[] args) throws InterruptedException {
        System.out.println("主线程开启");
        threadLocal.set(new UserSession("001","hello"));
        System.out.println("主线程读取本地变量：" + threadLocal.get());

        executorService.submit(() -> {
            System.out.println("子线程读取本地变量：" + threadLocal.get());
        });

        TimeUnit.SECONDS.sleep(1);

        threadLocal.get().setNickname("world");
        System.out.println("主线程读取本地变量：" + threadLocal.get());

        executorService.submit(() -> {
            //[没有读到了主线程修改后的新值]
            System.out.println("子线程读取本地变量：" + threadLocal.get());
            threadLocal.get().setNickname("Java");
            System.out.println("子线程读取本地变量：" + threadLocal.get());
        });

        TimeUnit.SECONDS.sleep(1);
        //依旧读取的是 world
        System.out.println("主线程读取本地变量：" + threadLocal.get());
    }
}

输出结果为：

主线程开启
主线程读取本地变量：UserSession(uuid=001, nickname=hello)
子线程读取本地变量：null
主线程读取本地变量：UserSession(uuid=001, nickname=world)
子线程读取本地变量：null
主线程读取本地变量：UserSession(uuid=001, nickname=world)

2.2 InheritableThreadLocal

class TransmittableThreadLocalTest5 {
    static ThreadLocal<UserSession> threadLocal = new InheritableThreadLocal<>();
    static ExecutorService executorService =
            Executors.newFixedThreadPool(1);

    public static void main(String[] args) throws InterruptedException {
        System.out.println("主线程开启");
        threadLocal.set(new UserSession("001","hello"));
        System.out.println("主线程读取本地变量：" + threadLocal.get());

        executorService.submit(() -> {
            System.out.println("子线程读取本地变量：" + threadLocal.get());
        });

        TimeUnit.SECONDS.sleep(1);

        threadLocal.get().setNickname("world");
        System.out.println("主线程读取本地变量：" + threadLocal.get());

        executorService.submit(() -> {
            //[读到了主线程修改后的新值]
            System.out.println("子线程读取本地变量：" + threadLocal.get());
            threadLocal.get().setNickname("Java");
            System.out.println("子线程读取本地变量：" + threadLocal.get());
        });

        TimeUnit.SECONDS.sleep(1);
        //读取的是 Java（因为浅拷贝）
        System.out.println("主线程读取本地变量：" + threadLocal.get());
    }
}

主线程开启
主线程读取本地变量：UserSession(uuid=001, nickname=hello)
子线程读取本地变量：UserSession(uuid=001, nickname=hello)
主线程读取本地变量：UserSession(uuid=001, nickname=world)
子线程读取本地变量：UserSession(uuid=001, nickname=world)
子线程读取本地变量：UserSession(uuid=001, nickname=Java)
主线程读取本地变量：UserSession(uuid=001, nickname=Java)

2.3 InheritableThreadLocal

class TransmittableThreadLocalTest6 {
    static ThreadLocal<UserSession> threadLocal = new TransmittableThreadLocal<>();
    static ExecutorService executorService =
            TtlExecutors.getTtlExecutorService(Executors.newFixedThreadPool(1));

    public static void main(String[] args) throws InterruptedException {
        System.out.println("主线程开启");
        threadLocal.set(new UserSession("001","hello"));
        System.out.println("主线程读取本地变量：" + threadLocal.get());

        executorService.submit(() -> {
            System.out.println("子线程读取本地变量：" + threadLocal.get());
        });

        TimeUnit.SECONDS.sleep(1);

        threadLocal.get().setNickname("world");
        System.out.println("主线程读取本地变量：" + threadLocal.get());

        executorService.submit(() -> {
            //[读到了主线程修改后的新值]
            System.out.println("子线程读取本地变量：" + threadLocal.get());
            threadLocal.get().setNickname("Java");
            System.out.println("子线程读取本地变量：" + threadLocal.get());
        });

        TimeUnit.SECONDS.sleep(1);
        //读取的是 Java（因为浅拷贝）
        System.out.println("主线程读取本地变量：" + threadLocal.get());
    }
}

输出结果与上面2.2的结果一样

参考文档：

  1. https://github.com/alibaba/transmittable-thread-local

全菜工程师小辉
关注
一文上手ThreadLocal使用和原理
Hi，我是sharkchili，CSDN Java领域博客专家，开源项目JavaGuide维护人员，我想写一些有意思的东西，希望对你有帮助。
01-04 2896
当我们某个类需要被多线程共享的时候，我们就可以使用ThreadLocal关键字，ThreadLocal可以为每个线程创建这个变量的副本并存到每个线程的存储空间中(关于这个存储空间后文会展开讲述)，从而确保共享变量对每个线程隔离，实现线程安全。//静态变量，所有线程共享一个connect//= null)代码很简单，问题也很明显，假如我们1000个线程同时去调用这个工具类建立数据库连接，很可能在同一个时间，同时指向getConnection方法。
【Java多线程】ThreadLocal 原理分析与使用场景
墩墩分墩
06-05 655
面试官：听说你看过ThreadLocal源码？我来瞅瞅？ Java并发之ThreadLocal 一文搞懂 ThreadLocal 原理 Java中ThreadLocal 原理分析与使用场景 ThreadLocal就是这么简单 再也不学ThreadLocal了，看这一篇就忘不掉了！（万字总结） 线程安全性？如何安全地使用 ThreadLocal ThreadLocal 和神奇的数字 0x61c88647 面试再问ThreadLocal，别说你不会 ThreadLocal可以解决并发问题吗 面试官再问你 Thr
异步线程threadLocal中对象获取失败
游语
03-19 1897
问题描述 在一个比较复杂的业务中，同步执行了主任务，将与当前任务无关的任务丢进了异步线程，然后发现异步线程没有获取到用户。所有的异步任务都没有执行下去。 排查 1.直接debug，发现任务在异步方法开始执行就失败了，没有进入异步方法； 2.打log，异步方法前的log打印了，之后的没有。 3.仔细看代码，发现了开启异步线程后入参直接来自threadLocal，找到问题了，明显的子线程获取父线程对象...
基础篇:资源拷贝之ThreadLocal(六)
打着吊瓶写代码的博客
04-09 1214
如果你有这样的需求，在不同的线程中对某个对象的修改不会影响到其它线程中该对象的状态，那么使用ThreadLocal将是非常不错的解决方案，事实上，这种需求是很常见的； 我们来演示一下ThreadLocal的工作机制： //测试线程本地存储,证明对象复制与多个线程对ThreadLocal变量的修改互不影响 private static void testLocalThread() throws
实现ThreadLocal在异步线程（包括线程池）中传递
avatar6780的博客
12-27 3544
JDK提供了本地线程共享的ThreadLocal和在创建线程时可继承的InheritableThreadLocal，但是由于大多数情况都推荐使用线程池来进行异步处理，InheritableThreadLocal就达不到我们的预期。但是可以参考它的实现思路，在进行线程间的传递时（如创建线程或创建Runnable实现类），将与父线程绑定的ThreadLocal值传递给子线程，就可实现父子线程ThreadLocal的传递。
异步线程中如何传递threadlocal中的信息
yeluowan的博客
09-29 2063
springboot+线程池
多线程系列-ThreadLocal
ahao' Blog
04-15 1437
线程安全-ThreadLocal 前言 共享资源被多个线程同时访问可能出现不安全的事情。线程安全一直是很重要的事情，没处理好线程安全的问题可能导致错误甚至很难复现排查。 常见的解决办法有定义不可变(immutable)变量：例如Java中的String类型、Guava库里的ImmutableCollections。还有就是对访问共享资源的线程加上锁：例如JUC包下的ReentrantLock和JDK自带的synchronized关键字，或者借助Unsafe类来实现的自旋锁。还有一种是保证所有执行的任务都一个
一文搞懂 ThreadLocal 原理
武培轩
04-05 2014
当多线程访问共享可变数据时，涉及到线程间同步的问题，并不是所有时候，都要用到共享数据，所以就需要线程封闭出场了。 数据都被封闭在各自的线程之中，就不需要同步，这种通过将数据封闭在线程中而避免使用同步的技术称为线程封闭。 本文主要介绍线程封闭中的其中一种体现：ThreadLocal，将会介绍什么是 ThreadLocal；从 ThreadLocal 源码角度分析，最后介绍 ThreadLocal 的...
threadlocal的过期数据_一文让你彻底明白ThreadLocal
weixin_39710179的博客
01-13 599
前言：ThreadLocal在JDK中是一个非常重要的工具类，通过阅读源码，可以在各大框架都能发现它的踪影。它最经典的应用就是 事务管理 ，同时它也是面试中的常客。今天就来聊聊这个ThreadLocal；本文主线：①、ThreadLocal 介绍②、ThreadLocal 实现原理③、ThreadLocal 内存泄漏分析④、ThreadLocal 应用场景及示例注：本文源码基于 JDK1.8Thr...
TransmittableThreadLocal详解，源码分析，一文带你掌握核心逻辑
最新发布
weixin_42293662的博客
01-05 837
到这里分析就结束了整体我认为这个设计的还是很巧妙的，解决了InheritableThreadLocal在线程复用(线程池的情况无法使用的问题)首先使用了holder这样一个ThreadLocal，记录了每一个线程使用了哪些threadLocal，到时候可以直接将这个线程所有的thread以及value遍历出来只用TtlRunnable把Runnable包装了一层，在调用.get时就把父线程打了个快照把Runnable的run方法包装了一层，让线程开始执行之前。
子线程如何获取父线程的ThreadLocal变量
远方的少年
07-15 1447
之前面试的时候，当谈到ThreadLocal时，被人问到，在子线程中如何获取父线程的ThreadLocal里面存储的变量。今天看到了一个类InheritableThreadLocal才明白原来是这样来做的。 先来看一下InheritableThreadLocal的源码。 public class InheritableThreadLocal<T> extends ThreadLocal<T> { /*...
浅谈ThreadLocal
u014089832的博客
02-29 279
什么是ThreadLocal ThreadLocal提供了线程的局部变量，每个线程都可以通过set()和get()来对这个局部变量进行操作，但不会和其他线程的局部变量进行冲突，实现了线程的数据隔离。 简要言之：往ThreadLocal中填充的变量属于当前线程，该变量对其他线程而言是隔离的。 ThreadLocal可以让我们拥有当前线程的变量，那这个作用有什么用呢？ *管理Conne...
Spring 异步线程中传递ThreadLocal
keep_learn的专栏
12-28 1545
ThreadLocal 的传递
ThreadLocal的坑--ThreadLocal跨线程传递问题
weixin_30244889的博客
04-28 637
1、父子线程间的传递问题 ThreadLocal的子类InheritableThreadLocal其实已经帮我们处理好了，通过这个组件可以实现父子线程之间的数据传递，在子线程中能够父线程中的ThreadLocal本地变量。 我们发现InheritableThreadLocal中createMap，以及getMap方法处理的对象不一样了，其中在ThreadLocal中处理的是threadLoc...
Java中ThreadLocal类（解决多线程程序中并发问题的一种新思路，主要为参数的拷贝问题）
Haiwi-Song
08-09 1138
百度百科的解释（部分摘抄）                  JDK 1.2的版本中就提供java.lang.ThreadLocal，ThreadLocal为解决多线程程序的并发问题提供了一种新的思路。使用这个工具类可以很简洁地编写出优美的多线程程序，ThreadLocal并不是一个Thread，而是Thread的局部变量。         ThreadLocal主要由四个方法组成i
详解ThreadLocal跨线程数据共享的设计和实现
HackDaily
03-26 3603
ThreadLocal跨线程数据同步，本质上还是依赖线程之间对象属性的拷贝
ThreadLocal原理解析
勿忘初心
08-20 1692
基于OpenJDK 12引本文主要想了解两个地方：ThreadLocal实例看起来是在多个线程共享，但实际上是彼此独立的，这个是怎么实现的？ThreadLocal使用不当...
面试必备之ThreadLocal
lonelymanontheway的博客
05-02 608
概述：空间换时间的思想，线程封闭技术，实现线程间数据隔离； 原理：源码分析，内部类，弱引用，可能存在的问题，对应的解决方法有两种； 用途； 强行与synchronized进行对比； 拓展：线程局部存储，线程局部握手，ThreadLocalRandom，InheritableThreadLocal，TransmittableThreadLocal，FastThreadLocal...
如何解决ThreadLocal在异步调用中的问题
weixin_30488313的博客
03-02 1297
1、首先大家都知道ThreadLocal中的get之所以能够保证线程安全是依赖于每个线程都会有一个ThreadLocalMap. 当执行set方法的时候首先会获取当前线程的ThreadLocalMap，然后给map赋值。 public void set(T value) { Thread t = Thread.currentThread(); Threa...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值