震惊!原来 threadLocal 还能这么用!

本贴最后更新于 1580 天前,其中的信息可能已经东海扬尘

--------------------------------------------------------------------------------
关于 threadLocal 如果你想了解更多,希望这边文章对你有所帮助。
--------------------------------------------------------------------------------

我想对于 threadLocal 大家都不会陌生,我们经常用他存储一些全局类型的变量,然后方便在整个调用链的各个地方使用,类似这样就可以。

    private static ThreadLocal<Object> threadLocal = new ThreadLocal<>();

    public static Object getThreadLocalValue() {
        return threadLocal.get();
    }

    public static void setThreadLocalValue(Object object) {
        threadLocal.set(object);
    }

我相信看过 threadLocal 的同学对于类似这样的使用方式都不会陌生,很简单的初始化 set()进去之后,在其他地方 get()方法获取就可以了。当然这篇文章的目的不是为了这个,首先第一个问题,new ThreadLocal<>()能不能在子线程中使用,如果我想在子线程中使用线程变量的副本怎么办?

屏幕快照 20191128 上午 12.30.20.png
果然,这个问题还是难不到你,我太天真了。
用 ThreadLocal 的子类 InheritableThreadLocal 啊,InheritableThreadLocal 在 threadLocal 的基础上,解决了和线程相关的副本从父线程向子线程传递的问题。他的实现原理是这样的 <erwog@!ff13dfslso%$#@dfsdl;>。你娓娓道来,胸前的红领巾都不自觉地鲜艳了起来。

看着你的陈述,那么的自信,我邪魅一笑,很好,你成功吸引了我的注意!
看来,不拿点压箱底的东西是镇不住你的了,问题真的来了,如果我想从线程池中拿到主线程的全局变量副本可以吗?
哼,不知道了吧,看我给你一一解释。什么??! 你知道?好吧,我们先假装你不会,不然这篇文章都写不下去了, 逃 : ) 求饶命 ~

先说结论,alibaba 提供了一种解决线程池中线程使用主线程中副本的办法 ----- TransmittableThreadLocal
解释 TransmittableThreadLocal 实现原理之前我们先回顾下,InheritableThreadLocal 为什么能保证子线程可以从父线程中拿到副本呢?

先看下我们在父线程中 new Thread()的时候都干了些啥:

public Thread(Runnable target) {
    init(null, target, "Thread-" + nextThreadNum(), 0);
}

我们再看下 init 这个初始化方法。

private void init(ThreadGroup g, Runnable target, String name,
                     long stackSize, AccessControlContext acc) {
 
    Thread parent = currentThread();
        
     <省略一些这篇文章不太关注的逻辑, 想要全面了解thread的初始化逻辑可翻看源码>
       
    if (parent.inheritableThreadLocals != null)
        this.inheritableThreadLocals =
            ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
       
}

ok,豁然开朗,原来在我们平时 new Thread()的时候已经把当前主线程也就是 currentThread()里面的 inheritableThreadLocal 副本给子线程拷贝了一份啊,自然地,子线程也就可以获得主线程变量的副本了。
那么为什么线程池会是什么结果呢?我们看个栗子。

public class Test {
    private static ThreadLocal<Map<String,String>> holder = new InheritableThreadLocal<>();
 
    public void testTtl(){
        // 构建线程池
        Executor executor = Executors.newFixedThreadPool(1);
 
        executor.execute(()-> System.out.println("init"));
 
        // 初始化ThreadLocal
        HashMap<String,String> map = new HashMap<>();
        map.put("1","2");
        holder.set(map);
 
        // 判断线程池中能够拿到主线程threadLocal副本
        executor.execute(()->{
            System.out.println(holder.get()); //结果为:null
        });
    }
     
    public static void main(String[] args) {
        new Test().testTtl();
    }
}

到现在,我们知道了,因为线程池中线程的复用,所以这个 inheritableThreadLocal 只能维持在这个线程创建时候的状态。
那么接下来,就是讲解为什么 alibaba 提供的 TransmittableThreadLocal 能够实现线程池中副本的传递。
TransmittableThreadLocal 继承了 InheritableThreadLocal,重载了 get 和 set 方法。

@Override
public final T get() {
    T value = super.get();
    if (null != value) addValue();
    return value;
}
 
@Override
public final void set(T value) {
    super.set(value);
    // may set null to remove value
    if (null == value) removeValue();
    else addValue();
}

可以看到在调用父类的逻辑上,新增了 addValue 和 removeValue 的逻辑,这个就是缓存的逻辑,会把当前这个 threadlocal 缓存到 holder 上面。

private void addValue() {
    if (!holder.get().containsKey(this)) {
        holder.get().put(this, null); // WeakHashMap supports null value.
    }
}
 
private void removeValue() {
    holder.get().remove(this);
}

下面介绍下这个很关键的 holder。

private static InheritableThreadLocal<Map<TransmittableThreadLocal<?>, ?>> holder =
new InheritableThreadLocal<Map<TransmittableThreadLocal<?>, ?>>() {
    @Override
    protected Map<TransmittableThreadLocal<?>, ?> initialValue() {
        return new WeakHashMap<TransmittableThreadLocal<?>, Object>();
    }
 
    @Override
    protected Map<TransmittableThreadLocal<?>, ?> childValue(Map<TransmittableThreadLocal<?>, ?> parentValue) {
        return new WeakHashMap<TransmittableThreadLocal<?>, Object>(parentValue);
    }
};

首先这个 holder 本身是 InheritableThreadLocal 类型的,所以它也是和线程相关联的。可以在父子线程间传递,但是对于线程池内已经创建的线程肯定是传递不进去的。所以在初始化 wrapper 类(包装类)的时候,那个时候还是父线程,在 wrapper 类构造的时候,要把这些 threadlocal 捕获出来,这个捕获相关逻辑见下一个 Transmitter 的分析。

Transmitter 内有 3 个核心方法,ttl 表示 TransmittableThreadLocal。

  • capture:捕获父线程的 ttl
  • replay:重放父线程 ttl
  • restore:恢复之前子线程的 ttl

capture 用于捕获父线程的 ttl,捕获操作要在父线程执行。

public static Object capture() {
    return new Snapshot(captureTtlValues(), captureThreadLocalValues());
}
 
private static WeakHashMap<TransmittableThreadLocal<Object>, Object> captureTtlValues() {
    WeakHashMap<TransmittableThreadLocal<Object>, Object> ttl2Value = new WeakHashMap<TransmittableThreadLocal<Object>, Object>();
    for (TransmittableThreadLocal<Object> threadLocal : holder.get().keySet()) {
        ttl2Value.put(threadLocal, threadLocal.copyValue());
    }
    return ttl2Value;
}
 
private static WeakHashMap<ThreadLocal<Object>, Object> captureThreadLocalValues() {
    final WeakHashMap<ThreadLocal<Object>, Object> threadLocal2Value = new WeakHashMap<ThreadLocal<Object>, Object>();
    for (Map.Entry<ThreadLocal<Object>, TtlCopier<Object>> entry : threadLocalHolder.entrySet()) {
        final ThreadLocal<Object> threadLocal = entry.getKey();
        final TtlCopier<Object> copier = entry.getValue();
 
        threadLocal2Value.put(threadLocal, copier.copy(threadLocal.get()));
    }
    return threadLocal2Value;
}

replay 传入 capture 方法捕获的 ttl,然后在子线程重放,也就是调用 ttl 的 set 方法,会设置到当前的线程中去,最后会把子线程之前存在的 ttl 返回。

public static Object replay(@NonNull Object captured) {
    final Snapshot capturedSnapshot = (Snapshot) captured;
    return new Snapshot(replayTtlValues(capturedSnapshot.ttl2Value), replayThreadLocalValues(capturedSnapshot.threadLocal2Value));
}
 
@NonNull
private static WeakHashMap<TransmittableThreadLocal<Object>, Object> replayTtlValues(@NonNull WeakHashMap<TransmittableThreadLocal<Object>, Object> captured) {
    WeakHashMap<TransmittableThreadLocal<Object>, Object> backup = new WeakHashMap<TransmittableThreadLocal<Object>, Object>();
 
    for (final Iterator<TransmittableThreadLocal<Object>> iterator = holder.get().keySet().iterator(); iterator.hasNext(); ) {
        TransmittableThreadLocal<Object> threadLocal = iterator.next();
 
        // backup
        backup.put(threadLocal, threadLocal.get());
 
        // clear the TTL values that is not in captured
        // avoid the extra TTL values after replay when run task
        if (!captured.containsKey(threadLocal)) {
            iterator.remove();
            threadLocal.superRemove();
        }
    }
 
    // set TTL values to captured
    setTtlValuesTo(captured);
 
    // call beforeExecute callback
    doExecuteCallback(true);
 
    return backup;
}
 
private static WeakHashMap<ThreadLocal<Object>, Object> replayThreadLocalValues(@NonNull WeakHashMap<ThreadLocal<Object>, Object> captured) {
    final WeakHashMap<ThreadLocal<Object>, Object> backup = new WeakHashMap<ThreadLocal<Object>, Object>();
 
    for (Map.Entry<ThreadLocal<Object>, Object> entry : captured.entrySet()) {
        final ThreadLocal<Object> threadLocal = entry.getKey();
        backup.put(threadLocal, threadLocal.get());
 
        final Object value = entry.getValue();
        if (value == threadLocalClearMark) threadLocal.remove();
        else threadLocal.set(value);
    }
 
    return backup;
}

最后就是执行结束,restore 之前的上下文,用到 replay 返回的 back。

public static void restore(@NonNull Object backup) {
    final Snapshot backupSnapshot = (Snapshot) backup;
    restoreTtlValues(backupSnapshot.ttl2Value);
    restoreThreadLocalValues(backupSnapshot.threadLocal2Value);
}

要把 capture,repaly 和 restore 的逻辑串起来,那么就需要看下面的 TtlRunnable 类,这个就是我一直说的包装类。

 private TtlRunnable(@Nonnull Runnable runnable, boolean releaseTtlValueReferenceAfterRun) {
        //捕获父线程ttl
        this.capturedRef = new AtomicReference<Object>(capture());
        this.runnable = runnable;
        this.releaseTtlValueReferenceAfterRun = releaseTtlValueReferenceAfterRun;
 }

在构造函数,也就是父线程,会通过 capture 捕获父线程的 ttl,然后保存在 capturedRef 中
在 run 方法中,replay,restore 逻辑一目了然。

@Override
public void run() {
    Object captured = capturedRef.get();
    if (captured == null || releaseTtlValueReferenceAfterRun && !capturedRef.compareAndSet(captured, null)) {
        throw new IllegalStateException("TTL value reference is released after run!");
    }
 
    Object backup = replay(captured);
    try {
        runnable.run();
    } finally {
        restore(backup);
    }
}

至此,关于如何在线程池中实现 TransmittableThreadLocal 副本的传递方案阐述完毕。
哈哈哈哈哈哈.jpg

那么我们有什么方便简单的方式使用这个 TransmittableThreadLocal 实现线程池中的线程变量副本传递吗?
当然有,alibaba 在提供了 TransmittableThreadLocal 的同时,提供了一个非常好用的使用方式 -- TtlExecutors.
TtlExecutors 使用起来非常的方便,在我们构建的线程池上面做个封装就好了。

        Executor executor = Executors.newFixedThreadPool(10);
	Executor ttlExecutor = TtlExecutors.getTtlExecutor(executor);

我们看一眼 TtlExecutors.getTtlExecutor()做了什么。

    public static Executor getTtlExecutor(@Nullable Executor executor) {
        if (TtlAgent.isTtlAgentLoaded() || null == executor || executor instanceof TtlEnhanced) {
            return executor;
        }
        return new ExecutorTtlWrapper(executor);
    }

其实就构建了一个包装类 ExecutorTtlWrapper,我们再跟进去看一眼,发现 ExecutorTtlWrapper 很简单,他实现 Executor,覆盖了 execute 方法。

    @Override
    public void execute(@NonNull Runnable command) {
        executor.execute(TtlRunnable.get(command));
    }

看到这我们发现原来这个 execute 方法根据我们传进来的 Runnable 构建了 TtlRunnable,TtlRunnable 我们在上面已经介绍,就是在这个类的 run()方法里面我们实现了线程池变量副本的传递。
当然除了 TtlExecutors 之外,还有通过 TtlAgent 使用 TransmittableThreadLocal 的办法,这里不做过多介绍了。
详细信息可以参考官方:https://github.com/alibaba/transmittable-thread-local

  • Java

    Java 是一种可以撰写跨平台应用软件的面向对象的程序设计语言,是由 Sun Microsystems 公司于 1995 年 5 月推出的。Java 技术具有卓越的通用性、高效性、平台移植性和安全性。

    3165 引用 • 8206 回帖
  • 线程
    120 引用 • 111 回帖 • 3 关注

相关帖子

欢迎来到这里!

我们正在构建一个小众社区,大家在这里相互信任,以平等 • 自由 • 奔放的价值观进行分享交流。最终,希望大家能够找到与自己志同道合的伙伴,共同成长。

注册 关于
请输入回帖内容 ...

推荐标签 标签

  • 以太坊

    以太坊(Ethereum)并不是一个机构,而是一款能够在区块链上实现智能合约、开源的底层系统。以太坊是一个平台和一种编程语言 Solidity,使开发人员能够建立和发布下一代去中心化应用。 以太坊可以用来编程、分散、担保和交易任何事物:投票、域名、金融交易所、众筹、公司管理、合同和知识产权等等。

    34 引用 • 367 回帖 • 2 关注
  • H2

    H2 是一个开源的嵌入式数据库引擎,采用 Java 语言编写,不受平台的限制,同时 H2 提供了一个十分方便的 web 控制台用于操作和管理数据库内容。H2 还提供兼容模式,可以兼容一些主流的数据库,因此采用 H2 作为开发期的数据库非常方便。

    11 引用 • 54 回帖 • 638 关注
  • Kotlin

    Kotlin 是一种在 Java 虚拟机上运行的静态类型编程语言,由 JetBrains 设计开发并开源。Kotlin 可以编译成 Java 字节码,也可以编译成 JavaScript,方便在没有 JVM 的设备上运行。在 Google I/O 2017 中,Google 宣布 Kotlin 成为 Android 官方开发语言。

    19 引用 • 33 回帖 • 21 关注
  • Python

    Python 是一种面向对象、直译式电脑编程语言,具有近二十年的发展历史,成熟且稳定。它包含了一组完善而且容易理解的标准库,能够轻松完成很多常见的任务。它的语法简捷和清晰,尽量使用无异义的英语单词,与其它大多数程序设计语言使用大括号不一样,它使用缩进来定义语句块。

    534 引用 • 671 回帖
  • Webswing

    Webswing 是一个能将任何 Swing 应用通过纯 HTML5 运行在浏览器中的 Web 服务器,详细介绍请看 将 Java Swing 应用变成 Web 应用

    1 引用 • 15 回帖 • 635 关注
  • NGINX

    NGINX 是一个高性能的 HTTP 和反向代理服务器,也是一个 IMAP/POP3/SMTP 代理服务器。 NGINX 是由 Igor Sysoev 为俄罗斯访问量第二的 Rambler.ru 站点开发的,第一个公开版本 0.1.0 发布于 2004 年 10 月 4 日。

    311 引用 • 546 回帖 • 56 关注
  • HBase

    HBase 是一个分布式的、面向列的开源数据库,该技术来源于 Fay Chang 所撰写的 Google 论文 “Bigtable:一个结构化数据的分布式存储系统”。就像 Bigtable 利用了 Google 文件系统所提供的分布式数据存储一样,HBase 在 Hadoop 之上提供了类似于 Bigtable 的能力。

    17 引用 • 6 回帖 • 32 关注
  • WordPress

    WordPress 是一个使用 PHP 语言开发的博客平台,用户可以在支持 PHP 和 MySQL 数据库的服务器上架设自己的博客。也可以把 WordPress 当作一个内容管理系统(CMS)来使用。WordPress 是一个免费的开源项目,在 GNU 通用公共许可证(GPLv2)下授权发布。

    45 引用 • 113 回帖 • 321 关注
  • JVM

    JVM(Java Virtual Machine)Java 虚拟机是一个微型操作系统,有自己的硬件构架体系,还有相应的指令系统。能够识别 Java 独特的 .class 文件(字节码),能够将这些文件中的信息读取出来,使得 Java 程序只需要生成 Java 虚拟机上的字节码后就能在不同操作系统平台上进行运行。

    180 引用 • 120 回帖 • 2 关注
  • 心情

    心是产生任何想法的源泉,心本体会陷入到对自己本体不能理解的状态中,因为心能产生任何想法,不能分出对错,不能分出自己。

    59 引用 • 369 回帖
  • Quicker

    Quicker 您的指尖工具箱!操作更少,收获更多!

    16 引用 • 68 回帖
  • 架构

    我们平时所说的“架构”主要是指软件架构,这是有关软件整体结构与组件的抽象描述,用于指导软件系统各个方面的设计。另外还有“业务架构”、“网络架构”、“硬件架构”等细分领域。

    139 引用 • 441 回帖
  • Hprose

    Hprose 是一款先进的轻量级、跨语言、跨平台、无侵入式、高性能动态远程对象调用引擎库。它不仅简单易用,而且功能强大。你无需专门学习,只需看上几眼,就能用它轻松构建分布式应用系统。

    9 引用 • 17 回帖 • 591 关注
  • RIP

    愿逝者安息!

    8 引用 • 92 回帖 • 285 关注
  • 招聘

    哪里都缺人,哪里都不缺人。

    189 引用 • 1056 回帖
  • FlowUs

    FlowUs.息流 个人及团队的新一代生产力工具。

    让复杂的信息管理更轻松、自由、充满创意。

    1 引用 • 3 关注
  • Rust

    Rust 是一门赋予每个人构建可靠且高效软件能力的语言。Rust 由 Mozilla 开发,最早发布于 2014 年 9 月。

    57 引用 • 22 回帖
  • 数据库

    据说 99% 的性能瓶颈都在数据库。

    330 引用 • 614 回帖
  • Love2D

    Love2D 是一个开源的, 跨平台的 2D 游戏引擎。使用纯 Lua 脚本来进行游戏开发。目前支持的平台有 Windows, Mac OS X, Linux, Android 和 iOS。

    14 引用 • 53 回帖 • 506 关注
  • Electron

    Electron 基于 Chromium 和 Node.js,让你可以使用 HTML、CSS 和 JavaScript 构建应用。它是一个由 GitHub 及众多贡献者组成的活跃社区共同维护的开源项目,兼容 Mac、Windows 和 Linux,它构建的应用可在这三个操作系统上面运行。

    15 引用 • 136 回帖
  • CSDN

    CSDN (Chinese Software Developer Network) 创立于 1999 年,是中国的 IT 社区和服务平台,为中国的软件开发者和 IT 从业者提供知识传播、职业发展、软件开发等全生命周期服务,满足他们在职业发展中学习及共享知识和信息、建立职业发展社交圈、通过软件开发实现技术商业化等刚性需求。

    14 引用 • 155 回帖
  • 运维

    互联网运维工作,以服务为中心,以稳定、安全、高效为三个基本点,确保公司的互联网业务能够 7×24 小时为用户提供高质量的服务。

    148 引用 • 257 回帖 • 1 关注
  • JetBrains

    JetBrains 是一家捷克的软件开发公司,该公司位于捷克的布拉格,并在俄国的圣彼得堡及美国麻州波士顿都设有办公室,该公司最为人所熟知的产品是 Java 编程语言开发撰写时所用的集成开发环境:IntelliJ IDEA

    18 引用 • 54 回帖
  • IDEA

    IDEA 全称 IntelliJ IDEA,是一款 Java 语言开发的集成环境,在业界被公认为最好的 Java 开发工具之一。IDEA 是 JetBrains 公司的产品,这家公司总部位于捷克共和国的首都布拉格,开发人员以严谨著称的东欧程序员为主。

    180 引用 • 400 回帖
  • GitBook

    GitBook 使您的团队可以轻松编写和维护高质量的文档。 分享知识,提高团队的工作效率,让用户满意。

    3 引用 • 8 回帖 • 1 关注
  • SendCloud

    SendCloud 由搜狐武汉研发中心孵化的项目,是致力于为开发者提供高质量的触发邮件服务的云端邮件发送平台,为开发者提供便利的 API 接口来调用服务,让邮件准确迅速到达用户收件箱并获得强大的追踪数据。

    2 引用 • 8 回帖 • 429 关注
  • CodeMirror
    1 引用 • 2 回帖 • 109 关注