TransmittableThreadLocal的简单使用 + 手写源码

最新推荐文章于 2026-05-22 10:07:28 发布
原创 最新推荐文章于 2026-05-22 10:07:28 发布 · 1.7k 阅读 · 8 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#多线程 #并发编程 #thread

文章目录

之前有一篇文章谈到链路追踪场景下，需要在异步线程之间，实现跨线程的ThreadLocal传递, 简单场景可以用InheritableThreadLocal，但ITL在线程池化场景下不适用，因为ITL是在子线程初始化时，拷贝了父线程的ThreadLocal，但池化场景，子线程是会被多次复用的，但ITL只能在子线程第一次创建时，传递ThreadLocal，之后的复用都无法重新设置ThreadLocal。于是TransmittableThreadLocal出现了，可以解决ThreadLocal在线程池化场景下的传递问题。

使用方法

  1. 引入依赖

    <dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>transmittable-thread-local</artifactId>
    <version>2.11.4</version>
</dependency>

  2. 创建TransmittableThreadLocal对象

  3. 提交Runnable对象到线程池中时,使用TtlRunnable进行包裹

如此，即可以完成ThreadLocal变量在父子线程之间的传递，并且不会出现InheritableThreadLocal在

线程池化场景下的问题

import com.alibaba.ttl.TransmittableThreadLocal;
import com.alibaba.ttl.TtlRunnable;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @author yogurtzzz
 * @date 2020/5/28 15:14
 **/
public class ThreadLocalTest {

    private static ThreadLocal<String> ttl = new TransmittableThreadLocal<>();

    /** 保证只有1个线程,以便观察这个线程被多个Runnable复用时，能否成功完成ThreadLocal的传递 **/
    private static ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
            1,1,0,TimeUnit.SECONDS,new ArrayBlockingQueue<>(10)
    );

    public static void main(String[] args) throws InterruptedException {
        ttl.set("yogurtzzz");

        for (int i = 0; i < 5; i++) {
            if (i == 2) {
                ttl.set("changed");
            }
            TtlRunnable runnable = TtlRunnable.get(() -> {
                System.out.println(Thread.currentThread().getName() + " : " + ttl.get());
            });

            threadPoolExecutor.execute(runnable);
            //CompletableFuture.runAsync(runnable,threadPoolExecutor);
            TimeUnit.MILLISECONDS.sleep(500);
        }
    }
}

结果：
在这里插入图片描述

原理

  1. TTL继承自InheritableThreadLocal
  2. 通过一个Holder，保存了每个线程当前持有的所有ThreadLocal对象
  3. 用TtlRunnable的get方法来包裹一个Runnable对象，包裹对象时，会采用类似SNAPSHOT，快照的机制，通过Holder，捕获父线程当前持有的所有ThreadLocal。随后，子线程启动，在Runnable对象执行run方法之前，从Holder中取出先前捕获到的父线程所持有的ThreadLocal对象，并设置到当前子线程当中，设置之前会保存子线程原有的ThreadLocal作为backUp，当子线程执行结束后，通过backUp恢复其原有的ThreadLocal

手写源码

下面仿造TTL的核心思路，手写了一个简单版的实现，也能解决ThreadLocal在线程间传递的问题

  1. CoreThreadLocal
import java.util.Iterator;
import java.util.WeakHashMap;
/**
 * @author yogurtzzz
 * @date 2020/5/28 15:11
 *
 * 简单版TransmittableThreadLocal
 * 用于处理InheritableThreadLocal在线程池化场景下的问题
 * 需配合CoreRunnable使用
 **/
public class CoreThreadLocal<T> extends InheritableThreadLocal<T> {
    /**
     * 用来保存当前线程持有的threadLocal
     * 它是static的
     * 所有线程都会有一个holder的threadLocal
     * 这个holder是一个map,保存着当前线程所持有的threadLocal
     * **/
    private static InheritableThreadLocal<WeakHashMap<CoreThreadLocal<Object>,?>> holder =
            new InheritableThreadLocal<WeakHashMap<CoreThreadLocal<Object>,?>>() {
                @Override
                protected WeakHashMap<CoreThreadLocal<Object>, ?> childValue(WeakHashMap<CoreThreadLocal<Object>, ?> parentValue) {
                    return new WeakHashMap<>(parentValue);
                }

                @Override
                protected WeakHashMap<CoreThreadLocal<Object>, ?> initialValue() {
                    return new WeakHashMap<>();
                }
            };

    @Override
    public T get() {
        T value = super.get();
        if (null != value) {
            addToHolder();
        }
        return value;
    }

    @Override
    public void set(T value) {
        if (null == value) {
            removeFromHolder();
            super.remove();
        }else {
            super.set(value);
            addToHolder();
        }
    }

    private void addToHolder() {
        if (!holder.get().containsKey(this)) {
            holder.get().put((CoreThreadLocal<Object>)this,null);
        }
    }

    private void removeFromHolder() {
        holder.get().remove(this);
    }

    static class Transmitter {
        /** 捕捉当前父线程的threadLocal **/
        public static SnapShot capture() {
            return new SnapShot(captureCtlValues());
        }

        private static WeakHashMap<CoreThreadLocal<Object>, Object> captureCtlValues() {
            WeakHashMap<CoreThreadLocal<Object>,Object> ctlValues = new WeakHashMap<>();
            /** 从holder中取当前线程持有的threadLocal **/
            for (CoreThreadLocal<Object> ctlItem : holder.get().keySet()) {
                ctlValues.put(ctlItem,ctlItem.get());
            }
            return ctlValues;
        }

        /**
         * 将capture设置到当前线程,并保存当前线程原有的threadLocal,返回
         * **/
        public static CoreThreadLocal.SnapShot replay(CoreThreadLocal.SnapShot snapShot) {
            WeakHashMap<CoreThreadLocal<Object>, Object> capture = snapShot.ctlValue;
            WeakHashMap<CoreThreadLocal<Object>, Object> backValue = new WeakHashMap<>();
            /**
             * 从holder中获取当前线程持有的threadLocal的Map,进行迭代保存
             * **/
            Iterator<CoreThreadLocal<Object>> iterator = holder.get().keySet().iterator();
            while (iterator.hasNext()) {
                CoreThreadLocal<Object> threadLocal = iterator.next();
                backValue.put(threadLocal,threadLocal.get());
                if (!capture.containsKey(threadLocal)) {
                    iterator.remove();
                    threadLocal.remove();
                }
            }
            /**
             * 设置上capture
             * */
            setThreadLocal(capture);
            return new SnapShot(backValue);
        }

        private static void setThreadLocal(WeakHashMap<CoreThreadLocal<Object>, Object> ctlValues) {
            ctlValues.forEach((key, value) -> {
                key.set(value);
            });
        }

        /**
         * 恢复为backUp
         * **/
        public static void restore(CoreThreadLocal.SnapShot backUp) {
            Iterator<CoreThreadLocal<Object>> iterator = holder.get().keySet().iterator();

            while (iterator.hasNext()) {
                CoreThreadLocal<Object> threadLocal = iterator.next();
                if (!backUp.ctlValue.containsKey(threadLocal)) {
                    iterator.remove();
                    threadLocal.remove();
                }
            }
            setThreadLocal(backUp.ctlValue);
        }
    }


    static class SnapShot {
        final WeakHashMap<CoreThreadLocal<Object>,Object> ctlValue;

        private SnapShot(WeakHashMap<CoreThreadLocal<Object>,Object> ctlValue) {
            this.ctlValue = ctlValue;
        }
    }
}
  1. CoreRunnable
public class CoreRunnable implements Runnable{

    private AtomicReference<CoreThreadLocal.SnapShot> captureRef;

    private Runnable runnable;

    private CoreRunnable(Runnable runnable) {
        this.runnable = runnable;
        captureRef = new AtomicReference<>(Transmitter.capture());
    }

    @Override
    public void run() {
        CoreThreadLocal.SnapShot capture = captureRef.get();
        CoreThreadLocal.SnapShot backUp = Transmitter.replay(capture);
        try{
            runnable.run();
        }finally {
            Transmitter.restore(backUp);
        }
    }

    /** 调用这个函数进行包装 **/
    public static CoreRunnable getRunnable(Runnable runnable) {
        return new CoreRunnable(runnable);
    }
}
  1. 测试
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @author yogurtzzz
 * @date 2020/6/4 13:05
 **/
public class Test {


    private static ThreadLocal<String> ttl = new CoreThreadLocal<>();

    /** 保证只有1个线程,以便观察这个线程被多个Runnable复用时，能否成功完成ThreadLocal的传递 **/
    private static ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
            1,1,0,TimeUnit.SECONDS,new ArrayBlockingQueue<>(10)
    );

    public static void main(String[] args) throws InterruptedException {
        ttl.set("yogurtzzz");

        for (int i = 0; i < 5; i++) {
            if (i == 2) {
                ttl.set("changed");
            }
            CoreRunnable runnable = CoreRunnable.getRunnable(() -> {
                System.out.println(Thread.currentThread().getName() + " : " + ttl.get());
            });

            threadPoolExecutor.execute(runnable);
            //CompletableFuture.runAsync(runnable,threadPoolExecutor);
            TimeUnit.MILLISECONDS.sleep(500);
        }
    }
}

结果：
在这里插入图片描述

TransmittableThreadLocal 使用详解、使用 TransmittableThreadLocal 解决在多线程环境下，线程切换时无法传递变量值的问题
川子的博客
08-23 5965
TransmittableThreadLocal是什么，TransmittableThreadLocal 和 ThreadLocal 的区别，TransmittableThreadLocal依赖文件、TransmittableThreadLocal的使用，TransmittableThreadLocal使用注意的点、线程之间值传递有哪些方式、TransmittableThreadLocal实现原理
阿里开源的TransmittableThreadLocal的正确使用姿势
m0_51681531的博客
04-28 1万+
TransmittableThreadLocal是阿里巴巴开源的一个线程本地变量，它是ThreadLocal的一个增强版，可以在线程池等多线程环境下使用，解决了ThreadLocal在多线程环境下的一些问题。在多线程环境下，ThreadLocal可以避免线程安全问题，但是在使用线程池等多线程环境时，ThreadLocal可能会出现一些问题。例如，当使用线程池时，线程池中的线程可能会被多个任务共享，如果使用ThreadLocal存储数据，可能会导致数据被错误地共享。
TransmittableThreadLocal原理及作用
最新发布
weixin_54009596的博客
05-22 264
在使用 TransmittableThreadLocal（TTL）实现异步线程上下文传递时，****必须使用 装饰线程池。如果不装饰，在线程池线程复用场景下，会出现上下文获取旧值、数据错乱的严重 BUG，导致线上用户信息、链路追踪、权限校验等业务异常。
TransmittableThreadLocal 四千字超详细讲解
sc35262的博客
05-07 1852
ITL 只是简单的实现了TLMap的线程上下文的赋值传递，但距离实际项目中使用还差很多功能，比如池化线程复用时的TL必须要在每次任务末尾进行情况否则下次任务会出现上次任务的TL值，部分业务场景需要引用对象应该遵循单向传递（就像 Vue 的父子组件的props传递那样）如果线程池触发了拒绝策略时由调用线程执行了任务末尾的ITL.remove 则会影响后续逻辑。
TransmittableThreadLocal详解
Mr1ght的博客
07-01 2万+
1、简介 TransmittableThreadLocal 是Alibaba开源的、用于解决 “在使用线程池等会缓存线程的组件情况下传递ThreadLocal” 问题的 InheritableThreadLocal 扩展。若希望 TransmittableThreadLocal 在线程池与主线程间传递，需配合 TtlRunnable 和 TtlCallable 使用。 2、使用场景 下面是几个典型场景例子。 分布式跟踪系统 应用容器或上层框架跨应用代码给下层SDK传递信息 日志收集记录系统上下文 3、源
TransmittableThreadLocal 源码分析
吉他程序员的博客
02-25 781
一. TransmittableThreadLocal 简介 传统的jdk的ThreadLocal只能解决线程或者父，子线程之间的数据传递。 而 TransmittableThreadLocal 是为了解决 线程池里面的线程之间传递ThreadLocal。 二. 实例带入 public static void main(String[] args) throws Exception { ThreadLocal<String> THREAD_LOCAL = new Transmit
TransmittableThreadLocal源码分析
weixin_70280523的博客
09-26 1202
666
TransmittableThreadLocal
scj1022的博客
02-18 1759
TransmittableThreadLocal的作用与源码分析
初识TransmittableThreadLocal
热门推荐
大鸡腿的博客
05-04 3万+
文章目录前言TransmittableThreadLocalmavendemo参考博客 前言 TransmittableThreadLocal是阿里开源的一个类，主要目的是处理父子线程变量不能共用的情况。ThreadLocal是跟当前线程挂钩的，所以脱离当前线程它就起不了作用。 ThreadLocal 场景：它的应用就是比如当前用户特有的一些属性，不能跟其他线程，用户共用。 Transmittab......
TransmittableThreadLocal剖析
CTZL123456的博客
09-10 5384
是 Alibaba 开源的 Java 库中的一个类。它扩展了 Java 标准库中的类，提供了跨线程传递本地变量（如跨线程池提交任务时）的能力。这在处理需要使用线程池的异步编程和并发场景下有大用处。要关注的是，需要配合装饰器使用，通过装饰器包装的可以确保在原始线程和执行任务的线程之间共享。ini代码解读复制代码。
TransmittableThreadLocal使用与详解
qq_41999771的博客
07-17 4948
TransmittableThreadLocal 是 Alibaba 开源的一个库，旨在解决在多线程环境中正确处理的问题。它提供了一个能够在线程间传递 ThreadLocal 值的特性。
TransmittableThreadLocal正确使用方式
weixin_42260270的博客
06-09 8786
TransmittableThreadLocal为什么没生效 ThreadLocal原理 TransmittableThreadLocal原理 TransmittableThreadLocal正确使用方式
TransmittableThreadLocal总结
weixin_43489232的博客
06-10 2489
在使用线程池等会池化复用线程的执行组件情况下，提供ThreadLocal值的传递功能，解决异步执行时上下文传递的问题。ThreadLocal使用场景针对线程不安全的例如SimpleDateFormat使用时能够支持多线程状态下的安全使用。同时不需要实例化过多实例和使用锁。} };上下文调用中屏蔽过多的方法栈中的传参（例如用户信息，客户端信息等存入，那么当前线程在任何地方需要时，都可以使用）} /*** 此方法可以支持在当前线程内任意地方获取客户端信息。
Java并发编程: TransmittableThreadLocal实现父子线程之间值传递
玉汝于成
04-04 2602
TransmittableThreadLocal 是 Alibaba 开源框架 transmittable-thread-local 中的一个核心类，它扩展了 Java 的标准 ThreadLocal 类。与标准的 ThreadLocal 不同，TransmittableThreadLocal 的值可以在线程之间传递，尤其是在线程池中的线程复用场景下。
TransmittableThreadLocal 学习
weixin_62558597的博客
11-29 3086
TransmittableThreadLocal是阿里巴巴开源的ThreadLocal增强工具，解决了线程池环境下ThreadLocal值无法传递的问题。使用时需引入依赖，通过TtlRunnable/TtlCallable修饰任务或使用TtlExecutors包装线程池实现上下文传递。其核心原理是在任务提交时捕获父线程变量，执行前恢复至子线程，完成后清理。相比ThreadLocal，它能自动管理跨线程数据传递，避免内存泄漏，简化异步编程中的上下文管理，特别适用于日志追踪等需要保持线程上下文的场景。注意同一任
TransmittableThreadLocal简单理解及使用
那仰望的人，心底的孤独和叹息
04-05 2416
TransmittableThreadLocal是对普通 ThreadLocal 的增强，它能够在多线程环境中安全地传递线程本地变量，并且能够在线程池中使用，但相应地可能会带来一定的性能开销。使ttl使用场景，简单理解，使用案例代码
TransmittableThreadLocal的使用
a18372016358的博客
01-11 508
TransmittableThreadLocal的使用
TransmittableThreadLocal 详解
csdn_tom_168的博客
06-24 1658
TransmittableThreadLocal（TTL）是阿里巴巴开源的高效线程本地变量解决方案，专为解决线程池场景下的上下文传递问题而设计。它继承自InheritableThreadLocal，通过装饰器模式包装线程池和任务，实现父线程到子线程的值无缝传递。核心特性包括跨线程池上下文传递、弱引用键防泄漏和多级继承控制，适用于分布式追踪、日志MDC等场景。TTL采用三级缓存策略和自动清理机制确保内存安全，提供任务装饰器TtlRunnable和线程池包装器TtlExecutor两种实现方式。最佳实践方面，建
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值