AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

ThreadLocal、InheritThreadLocal、TransmittableThreadLocal

2024-04-09 102
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： ThreadLocal、InheritThreadLocal、TransmittableThreadLocal

一、ThreadLocal

多线程是Java实现多任务的基础，Thread对象代表一个线程，我们可以在代码中调用Thread.currentThread()获取当前线程。例如，打印日志时，可以同时打印出当前线程的名字，

对于多任务，Java标准库提供的线程池可以方便地执行这些任务，同时复用线程。Web应用程序就是典型的多任务应用，每个用户请求页面时，我们都会创建一个任务，类似：

public void process(User user) {
    checkPermission();
    doWork();
    saveStatus();
    sendResponse();
}

然后，通过线程池去执行这些任务。

观察process()方法，它内部需要调用若干其他方法，同时，我们遇到一个问题：如何在一个线程内传递状态？

process()方法需要传递的状态就是User实例。有的童鞋会想，简单地传入User就可以了：

public void process(User user) {
    checkPermission(user);
    doWork(user);
    saveStatus(user);
    sendResponse(user);
}

但是往往一个方法又会调用其他很多方法，这样会导致User传递到所有地方：

void doWork(User user) {
    queryStatus(user);
    checkStatus();
    setNewStatus(user);
    log();
}

这种在一个线程中，横跨若干方法调用，需要传递的对象，我们通常称之为上下文（Context），它是一种状态，可以是用户身份、任务信息等。

给每个方法增加一个context参数非常麻烦，而且有些时候，如果调用链有无法修改源码的第三方库，User对象就传不进去了。

Java标准库提供了一个特殊的ThreadLocal，它可以在一个线程中传递同一个对象。

ThreadLocal实例通常总是以静态字段初始化如下：

static ThreadLocal<User> threadLocalUser = new ThreadLocal<>();

它的典型使用方式如下：

void processUser(user) {
    try {
        threadLocalUser.set(user);
        step1();
        step2();
    } finally {
        threadLocalUser.remove();
    }
}

通过设置一个User实例关联到ThreadLocal中，在移除之前，所有方法都可以随时获取到该User实例：

void step1() {
    User u = threadLocalUser.get();
    log();
    printUser();
}
 
void log() {
    User u = threadLocalUser.get();
    println(u.name);
}
 
void step2() {
    User u = threadLocalUser.get();
    checkUser(u.id);
}

注意到普通的方法调用一定是同一个线程执行的，所以，step1()、step2()以及log()方法内，threadLocalUser.get()获取的User对象是同一个实例。

实际上，可以把ThreadLocal看成一个全局Map<Thread, Object>：每个线程获取ThreadLocal变量时，总是使用Thread自身作为key：

Object threadLocalValue = threadLocalMap.get(Thread.currentThread());

因此，ThreadLocal相当于给每个线程都开辟了一个独立的存储空间，各个线程的ThreadLocal关联的实例互不干扰。

最后，特别注意ThreadLocal一定要在finally中清除：

try {
    threadLocalUser.set(user);
    ...
} finally {
    threadLocalUser.remove();
}

这是因为当前线程执行完相关代码后，很可能会被重新放入线程池中，如果ThreadLocal没有被清除，该线程执行其他代码时，会把上一次的状态带进去。

为了保证能释放ThreadLocal关联的实例，我们可以通过AutoCloseable接口配合try (resource) {...}结构，让编译器自动为我们关闭。例如，一个保存了当前用户名的ThreadLocal可以封装为一个UserContext对象：

public class UserContext implements AutoCloseable {
 
    static final ThreadLocal<String> ctx = new ThreadLocal<>();
 
    public UserContext(String user) {
        ctx.set(user);
    }
 
    public static String currentUser() {
        return ctx.get();
    }
 
    @Override
    public void close() {
        ctx.remove();
    }
}

使用的时候，我们借助try (resource) {...}结构，可以这么写：

try (var ctx = new UserContext("Bob")) {
    // 可任意调用UserContext.currentUser():
    String currentUser = UserContext.currentUser();
} // 在此自动调用UserContext.close()方法释放ThreadLocal关联对象

这样就在UserContext中完全封装了ThreadLocal，外部代码在try (resource) {...}内部可以随时调用UserContext.currentUser()获取当前线程绑定的用户名。

ThreadLocal只是线程传递，但是当在本线程中创建了一个新的线程，比如说又new了一个Thread的情况下，就不能把ThreadLocal中的数据传递给子线程。此时解决办法是通过InheritThreadLocal来解决

二、InheritThreadLocal

同一个ThreadLocal变量在父线程中被设置值后，在子线程中是获取不到的。而子类InheritableThreadLocal提供了一个特性，就是让子线程可以访问在父线程中设置的本地变量

当提交一个新任务到线程池时，线程池的处理流程如下：

  • 线程池判断线程数是否达到核心线程数且线程都处于工作状态。如果不是，则创建一个新的工作线程来执行任务。否则进入下个流程
  • 线程池判断工作队列是否已经满。如果工作队列没有满，则将新提交的任务存储在这个工作队列里。否则进入下个流程
  • 线程池判断线程数是否达到最大线程数且线程都处于工作状态。如果没有，则创建一个新的工作线程来执行任务。否则按照策略处理无法执行的任务

如果使用InheritableThreadLocal+线程池，提交任务时导致线程池创建了新的工作线程，此时工作线程（子线程）能够访问到父线程（提交任务的线程）的本地变量；如果提交任务复用了已经创建的工作线程，此时工作线程（子线程）访问的本地变量来源于第一个提交任务给该工作线程的外部线程，造成线程本地变量混乱

 

public class InheritableThreadLocalDemo {
    /**
     * 模拟tomcat线程池
     */
    private static ExecutorService tomcatExecutors = Executors.newFixedThreadPool(10);
 
    /**
     * 业务线程池,默认Control中异步任务执行线程池
     */
    private static ExecutorService businessExecutors = Executors.newFixedThreadPool(5);
 
    /**
     * 线程上下文环境,模拟在Control这一层,设置环境变量,然后在这里提交一个异步任务,模拟在子线程中,是否可以访问到刚设置的环境变量值
     */
    private static InheritableThreadLocal<Integer> requestIdThreadLocal = new InheritableThreadLocal<>();
 
    /**
     * 模式10个请求,每个请求执行ControlThread的逻辑,其具体实现就是,先输出父线程的名称,
     * 然后设置本地环境变量,并将父线程名称传入到子线程中,在子线程中尝试获取在父线程中的设置的环境变量
     *
     * @param args
     * @throws InterruptedException
     */
    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 10; ++i) {
            tomcatExecutors.submit(new ControlThread(i));
        }
 
        TimeUnit.SECONDS.sleep(10);
        businessExecutors.shutdown();
        tomcatExecutors.shutdown();
    }
 
    /**
     * 模拟Control任务
     */
    static class ControlThread implements Runnable {
        private int i;
 
        public ControlThread(int i) {
            this.i = i;
        }
 
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + ":" + i);
            requestIdThreadLocal.set(i);
            //使用线程池异步处理任务
            businessExecutors.submit(new BusinessTask(Thread.currentThread().getName()));
        }
    }
 
    /**
     * 业务任务,主要是模拟在Control控制层,提交任务到线程池执行
     */
    static class BusinessTask implements Runnable {
        private String parentThreadName;
 
        public BusinessTask(String parentThreadName) {
            this.parentThreadName = parentThreadName;
        }
 
        @Override
        public void run() {
            //如果与上面的能对应上来,则说明正确,否则失败
            System.out.println("parentThreadName:" + parentThreadName + ":" + requestIdThreadLocal.get());
        }
    }
}

其中一次执行结果如下：

pool-1-thread-1:0

pool-1-thread-4:3

pool-1-thread-3:2

pool-1-thread-2:1

pool-1-thread-6:5

pool-1-thread-5:4

pool-1-thread-7:6

pool-1-thread-8:7

pool-1-thread-9:8

pool-1-thread-10:9

parentThreadName:pool-1-thread-1:0

parentThreadName:pool-1-thread-4:3

parentThreadName:pool-1-thread-8:3

parentThreadName:pool-1-thread-7:6

parentThreadName:pool-1-thread-10:0

parentThreadName:pool-1-thread-3:3

parentThreadName:pool-1-thread-5:4

parentThreadName:pool-1-thread-2:1

parentThreadName:pool-1-thread-9:6

parentThreadName:pool-1-thread-6:0

在子线程中出现出现了线程本地变量混乱的现象

InheritThreadLocal解决了创建新的子线程的传递问题。但是如果我们使用的并不是通过new Thread的办法异步创建线程，而是通过线程池来进行异步来解决。如果线程池新建线程的话，使用InheritThreadLocal可以保证数据的传递。但是线程池中的线程是重复使用的，当重复使用线程的时候，重复使用的线程中的InheritThreadLocal仍然是上次创建的数据。此时解决办法可以参考阿里的TransmittableThreadLocal

 

三、TransmittableThreadLocal

依赖

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

使用

 

public class TransmittableThreadLocalDemo {
    /**
     * 模拟tomcat线程池
     */
    private static ExecutorService tomcatExecutors = Executors.newFixedThreadPool(10);
 
    /**
     * 业务线程池,默认Control中异步任务执行线程池 使用ttl线程池
     */
    private static ExecutorService businessExecutors = TtlExecutors.getTtlExecutorService(Executors.newFixedThreadPool(5));
 
    /**
     * 线程上下文环境,模拟在Control这一层,设置环境变量,然后在这里提交一个异步任务,模拟在子线程中,是否可以访问到刚设置的环境变量值
     */
    private static TransmittableThreadLocal<Integer> requestIdThreadLocal = new TransmittableThreadLocal<>();
 
    /**
     * 模式10个请求,每个请求执行ControlThread的逻辑,其具体实现就是,先输出父线程的名称,
     * 然后设置本地环境变量,并将父线程名称传入到子线程中,在子线程中尝试获取在父线程中的设置的环境变量
     *
     * @param args
     * @throws InterruptedException
     */
    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 10; ++i) {
            tomcatExecutors.submit(new ControlThread(i));
        }
 
        TimeUnit.SECONDS.sleep(10);
        businessExecutors.shutdown();
        tomcatExecutors.shutdown();
    }
 
    /**
     * 模拟Control任务
     */
    static class ControlThread implements Runnable {
        private int i;
 
        public ControlThread(int i) {
            this.i = i;
        }
 
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + ":" + i);
            requestIdThreadLocal.set(i);
            //使用线程池异步处理任务
            businessExecutors.submit(new BusinessTask(Thread.currentThread().getName()));
        }
    }
 
    /**
     * 业务任务,主要是模拟在Control控制层,提交任务到线程池执行
     */
    static class BusinessTask implements Runnable {
        private String parentThreadName;
 
        public BusinessTask(String parentThreadName) {
            this.parentThreadName = parentThreadName;
        }
 
        @Override
        public void run() {
            //如果与上面的能对应上来,则说明正确,否则失败
            System.out.println("parentThreadName:" + parentThreadName + ":" + requestIdThreadLocal.get());
        }
    }
}

执行结果符合预期结果

阿里的解决方式仍然是使用的InheritThreadLocal，不同的是，阿里通过Javaagent修改了线程池的字节码，在线程池创建Runnable或者Callable的时候进行了包装，我们就叫RunnableWrapper。把需要传递的数据在new RunnableWrapper的时候就传递到了RunnableWrapper的成员变量中。在RunnableWrapper执行run方法的时候，先将成员变量的数据重新放一遍ThreadLocal，然后再真正执行被包装的Runnable的run方法。这样在真正的run方法中就可以拿到ThreadLocal的数据

实际项目使用TransmittableThreadLocal时，需要对线程池进行封装才可以，比如常用的线程池创建方式：

1、ExecutorService ExecutorService service = Executors.newFixedThreadPool(5);

使用TransmittableThreadLocal，需要对创建的ExecutorService封装。

ExecutorService businessExecutors = TtlExecutors.getTtlExecutorService(Executors.newFixedThreadPool(5));

2、定义一个TtlThreadPoolTaskExecutor，继承ThreadPoolTaskExecutor，重写submit/execute方法，在初始化线程池时，使用TtlThreadPoolTaskExecutor即可

public class TtlThreadPoolTaskExecutor extends ThreadPoolTaskExecutor {
 
    @Override
    public void execute(Runnable command) {
        Runnable ttlRunnable = TtlRunnable.get(command);
        super.execute(ttlRunnable);
    }
 
    @Override
    public <T> Future<T> submit(Callable<T> task) {
        Callable ttCallable = TtlCallable.get(task);
        return super.submit(ttCallable);
    }
 
    @Override
    public Future<?> submit(Runnable task) {
        Runnable ttlRunnable = TtlRunnable.get(task);
        return super.submit(ttlRunnable);
    }
 
    @Override
    public ListenableFuture<?> submitListenable(Runnable task){
        Runnable ttlRunnable = TtlRunnable.get(task);
        return super.submitListenable(ttlRunnable);
    }
 
    @Override
    public <T> ListenableFuture<T> submitListenable(Callable<T> task) {
        Callable ttlCallable = TtlCallable.get(task);
        return super.submitListenable(ttlCallable);
    }
 
}

要使用的地方

ThreadPoolTaskExecutor threadPoolTaskExecutor = new TtlThreadPoolTaskExecutor();

spring容器中可以定义为bean全局使用

@Configuration
public class ThreadPoolConfig {
 
    @Value("${config.thread.pool.core_pool_size:20}")
    private Integer corePoolSize;
 
    @Value("${config.thread.pool.max_pool_size:100}")
    private Integer maxPoolSize;
 
    @Value("${config.thread.pool.keep_alive_seconds:2}")
    private Integer keepAliveSeconds;
 
    @Value("${config.thread.pool.queue_capacity:200}")
    private Integer queueCapacity;
 
    @Value("${config.thread.pool.allow_core_thread_timeout:true}")
    private String allowCoreThreadTimeOut;
 
    @Bean
    public ThreadPoolTaskExecutor threadPoolTaskExecutor() {
        ThreadPoolTaskExecutor threadPoolTaskExecutor = new TtlThreadPoolTaskExecutor();
        threadPoolTaskExecutor.setCorePoolSize(corePoolSize);
        threadPoolTaskExecutor.setMaxPoolSize(maxPoolSize);
        threadPoolTaskExecutor.setKeepAliveSeconds(keepAliveSeconds);
        threadPoolTaskExecutor.setQueueCapacity(queueCapacity);
        threadPoolTaskExecutor.setAllowCoreThreadTimeOut(Boolean.parseBoolean(allowCoreThreadTimeOut));
        threadPoolTaskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        return threadPoolTaskExecutor;
    }
 
}

依赖注入使用

@Autowired

private ThreadPoolTaskExecutor threadPoolTaskExecutor;

threadPoolTaskExecutor.submit(() -> {

   //任务

});



文章标签：
Java
容器
Spring
存储
编译器
程序三两行
目录
相关文章
FeelTouchLabs
|
2月前
|
Java 测试技术 索引
ThreadLocal详解
文章详细讨论了Java中的`ThreadLocal`，包括它的基本使用、定义、内部数据结构`ThreadLocalMap`、主要方法（set、get、remove）的源码解析，以及内存泄漏问题和避免策略。`ThreadLocal`提供了线程局部变量，确保多线程环境下各线程变量的独立性，但不当使用可能导致内存泄漏，因此建议在不再需要`ThreadLocal`变量时调用其`remove`方法。
FeelTouchLabs
76 2
ThreadLocal详解
bbpp
|
5月前
|
存储 Java 数据管理
ThreadLocal的使用
`ThreadLocal`是Java中的线程局部变量工具，确保每个线程都有自己的变量副本，互不干扰。适用于保持线程安全性数据和跨方法共享数据。基本用法包括创建实例、设置和获取值以及清除值。例如，创建ThreadLocal对象后，使用`.set()`设置值，`.get()`获取值，`.remove()`清除值。注意ThreadLocal可能引起内存泄漏，应适时清理，并谨慎使用以避免影响代码可读性和线程安全性。它是多线程编程中实现线程局部数据管理的有效手段。
bbpp
79 10
人不走空
|
5月前
|
存储 Java
ThreadLocal 有什么用
ThreadLocal 有什么用
人不走空
46 0
BookSea
|
存储 算法 安全
深入详解ThreadLocal
在我们日常的并发编程中，有一种神奇的机制在静悄悄地为我们解决着各种看似棘手的问题，它就是 ThreadLocal 。
BookSea
21489 9
深入详解ThreadLocal
快乐阿超
|
10月前
|
存储
ThreadLocal
ThreadLocal
快乐阿超
45 0
赵广陆
|
存储 安全 Java
ThreadLocal介绍和应用
ThreadLocal介绍和应用
赵广陆
48 0
大汉学友
|
存储 SQL Java
ThreadLocal的其他应用
request对象跟PageHelper
大汉学友
96 0
清蒸moon
|
存储 Java 数据库连接
对ThreadLocal的一点了解
ThreadLocal是线程变量，它为每个线程提供单独的存储空间。其主要作用是做线程间的数据隔离，也可以用于在同一个线程间方便地进行数据共享。（对于多线程资源共享，加锁机制采用“时间换空间”，ThreadLocal采用“空间换时间”）
清蒸moon
123 0
dc73hre37f4my
|
存储
ThreadLocal你懂了，你还懂TransmittableThreadLocal嘛？
ThreadLocal你懂了，你还懂TransmittableThreadLocal嘛？
dc73hre37f4my
387 0
知识浅谈
|
存储 Java
ThreadLocal相关使用
ThreadLocal相关使用
知识浅谈
186 0
ThreadLocal相关使用