ThreadLocal值传递问题

已于 2023-02-05 22:18:46 修改
阅读量1.4k 收藏 1
点赞数
分类专栏： 日记 笔记 文章标签： java
于 2023-02-04 17:11:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zkkzpp258/article/details/128883226
版权

ThreadLocal

ThreadLocal是Thread的局部变量，可以理解为ThreadLocalVariable。它在ThreadLocal类中定义了一个ThreadLocalMap，每一个Thread中都有一个该类型的变量——threadLocals——用于存储每一个线程的变量副本，Map中元素的键为线程对象，而值对应线程的变量副本。

ThreadLocal在不同线程之间值传递

ThreadLocal与当前线程绑定的变量赋值时，那切换到其他线程则获取不到该值，那么下面看看有没有什么解决办法。

现象解决方案描述
同一线程之间传递值ThreadLocal给线程提供一个本地变量，当线程消失的时候，所有的本地示例都会被回收
父子线程之间传递值InheritableThreadLocaljdk提供的类，是ThreadLocal的升级版，解决父子线程之间传递值的问题
线程池不同线程传递值TransmittableThreadLocal简称TTL，是阿里巴巴团队提供的一个框架，主要解决因为存储线程池InheritableThreadLocal失效的问题

ThreadLocal示例

示例一 ThreadLocal线程隔离

ThreadLocal是线程的本地变量，下面一个示例是启了十个线程，每个线程都有一个ThreadLocal，每个线程里初始化值都是100，然后每个线程中去改变变量值+1，最后结果可以看出每个线程都是互不影响的。

public class ThreadLocalMapDemo extends Thread {
    /**
     * ThreadLocal特性：
     * 1、线程并发：在多线程并发场景下使用。
     * 2、传递数据：可以通过ThreadLocal在同一线程，不同组件中传递公共变量。
     * 3、线程隔离：每个线程变量都是独立的，不会相互影响。
     *
     * ThreadLocalMap是ThreadLocal的静态内部类
     * 与HashMap类似，初始容量默认是16，初始容量必须是2的整数幂。通过Entry类的数据table存放数据。size是存放的数量，threshold是扩容阈值。
     * Entry继承自WeakReference，key是弱引用，其目的是将ThreadLocal对象的生命周期和线程生命周期解绑。
     * 弱引用：垃圾回收器一旦发现了弱引用的对象，不管内存是否足够，都会回收它的内存。
     */
    private static final ThreadLocal<Integer> THREAD_LOCAL = new ThreadLocal<>();
    private Integer value;

    ThreadLocalMapDemo(Integer value) {
        this.value = value;
    }

    @Override
    public void run() {
        // 设置值不会影响其他线程
        THREAD_LOCAL.set(value);
        System.out.println("Thread name = " + currentThread().getName() + " current value = " + THREAD_LOCAL.get());
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 重新设置值
        THREAD_LOCAL.set(THREAD_LOCAL.get() + 1);
        System.out.println("Thread name = " + currentThread().getName() + " current value after change is = " + THREAD_LOCAL.get());
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            ThreadLocalMapDemo demo = new ThreadLocalMapDemo(100);
            demo.setName("线程" + i);
            demo.start();
        }
    }
}

示例二

首先，定义一个ThreadLocal工具类，

/**
 * ThreadLocal工具类
 *
 * @param <T> 范型T
 */
public final class ThreadLocalUtil<T> {
    private final ThreadLocal<T> THREAD_LOCAL = new ThreadLocal<>();

    /**
     * 无参构造函数
     */
    public ThreadLocalUtil() {
    }

    /**
     * 有参构造函数
     *
     * @param t
     */
    ThreadLocalUtil(T t) {
        THREAD_LOCAL.set(t);
    }

    /**
     * 从ThreadLocalMap中获取当前线程变量
     *
     * @return 变量值
     */
    public T getValue() {
        return THREAD_LOCAL.get();
    }

    /**
     * ThreadLocalMap中写入当前线程变量
     *
     * @param t 入参
     * @return 当前写入值
     */
    public T setValue(T t) {
        THREAD_LOCAL.set(t);
        return t;
    }

    /**
     * 从ThreadLocalMap中删除当前线程变量
     */
    public void removeValue() {
        THREAD_LOCAL.remove();
    }
}

主线程中定义一个静态变量util，初始值是123，在子线程和主线程中分别打印ThreadLocal变量值。

public class ThreadLocalExample {
    private static Logger logger = LoggerFactory.getLogger(ThreadLocalExample.class);
    private static ThreadLocalUtil<Integer> util = new ThreadLocalUtil<>(123);

    public static void main(String[] args) {
        new Thread(() -> logger.info("Thread name = {}, thread variable is {}", Thread.currentThread().getName(), util.getValue())).start();
        logger.info("Thread name = {}, thread variable is {}", Thread.currentThread().getName(), util.getValue());
    }
}

示例结果如下，子线程输出的是子线程初始值null，主线程输出的是初始值123。另外，这里不保证线程的有序性，只是简易示例。
在这里插入图片描述

InheritableThreadLocal（ITL）示例

InheritableThreadLocal主要用于子线程创建时，需要自动继承父线程的ThreadLocal变量时使用。
把上面的代码稍微改造一下，

/**
 * ThreadLocal工具类
 *
 * @param <T> 范型T
 */
public final class ThreadLocalUtil<T> {
    private final ThreadLocal<T> THREAD_LOCAL = new InheritableThreadLocal<>();

    /**
     * 无参构造函数
     */
    public ThreadLocalUtil() {
    }

    /**
     * 有参构造函数
     *
     * @param t
     */
    ThreadLocalUtil(T t) {
        THREAD_LOCAL.set(t);
    }

    /**
     * 从ThreadLocalMap中获取当前线程变量
     *
     * @return 变量值
     */
    public T getValue() {
        return THREAD_LOCAL.get();
    }

    /**
     * ThreadLocalMap中写入当前线程变量
     *
     * @param t 入参
     * @return 当前写入值
     */
    public T setValue(T t) {
        THREAD_LOCAL.set(t);
        return t;
    }

    /**
     * 从ThreadLocalMap中删除当前线程变量
     */
    public void removeValue() {
        THREAD_LOCAL.remove();
    }
}

代码不变，子线程中输出的ThreadLocal变量继承了主线程中的ThreadLocal变量值，
在这里插入图片描述

TransmittableThreadLocal（TTL）示例

TransmittableThreadLocal，简称TTL，它不同于ITL，它能实现池化线程间传递。直接看官方的时序图，
在这里插入图片描述
大部分过程都依赖于 TransmittableThreadLocal 或 TransmittableThreadLocal 中声明的静态工具类 Transmitter 。Transmitter 主要负责 ThreadLocal 的管理和值的传递。

使用前需要导入依赖，

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

下面启了两个线程main_01和main_02作为父线程，线程池中执行的三个子线程拿到父线程设置的ttl变量，父线程再修改ttl值，然后线程池中的子线程继续读取ttl中的值。

import com.alibaba.ttl.TransmittableThreadLocal;
import com.alibaba.ttl.threadpool.TtlExecutors;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class TransmittableThreadLocalDemo {
    /**
     * 需要注意的是，使用TTL的时候，要想传递的值不出问题，线程池必须得用TTL加一层代理
     */
    private static ExecutorService executorService = TtlExecutors.getTtlExecutorService(Executors.newFixedThreadPool(2));
    private static ThreadLocal<Integer> ttl = new TransmittableThreadLocal<>();

    public static void main(String[] args) {
        new Thread(() -> {
            String mainThreadName = "main_01";
            ttl.set(1);
            executorService.execute(() -> {
                sleep(1L);
                System.out.println(String.format("本地变量改变之前(1), 父线程名称-%s, 子线程名称-%s, 变量值=%s", mainThreadName, Thread.currentThread().getName(), ttl.get()));
            });

            executorService.execute(() -> {
                sleep(1L);
                System.out.println(String.format("本地变量改变之前(1), 父线程名称-%s, 子线程名称-%s, 变量值=%s", mainThreadName, Thread.currentThread().getName(), ttl.get()));
            });

            executorService.execute(() -> {
                sleep(1L);
                System.out.println(String.format("本地变量改变之前(1), 父线程名称-%s, 子线程名称-%s, 变量值=%s", mainThreadName, Thread.currentThread().getName(), ttl.get()));
            });

            sleep(1L); //确保上面的会在tl.set执行之前执行
            ttl.set(2); // 等上面的线程池第一次启用完了，父线程再给自己赋值

            executorService.execute(() -> {
                sleep(1L);
                System.out.println(String.format("本地变量改变之后(2), 父线程名称-%s, 子线程名称-%s, 变量值=%s", mainThreadName, Thread.currentThread().getName(), ttl.get()));
            });

            executorService.execute(() -> {
                sleep(1L);
                System.out.println(String.format("本地变量改变之后(2), 父线程名称-%s, 子线程名称-%s, 变量值=%s", mainThreadName, Thread.currentThread().getName(), ttl.get()));
            });

            executorService.execute(() -> {
                sleep(1L);
                System.out.println(String.format("本地变量改变之后(2), 父线程名称-%s, 子线程名称-%s, 变量值=%s", mainThreadName, Thread.currentThread().getName(), ttl.get()));
            });

            System.out.println(String.format("线程名称-%s, 变量值=%s", Thread.currentThread().getName(), ttl.get()));

        }).start();


        new Thread(() -> {

            String mainThreadName = "main_02";

            ttl.set(3);

            executorService.execute(() -> {
                sleep(1L);
                System.out.println(String.format("本地变量改变之前(3), 父线程名称-%s, 子线程名称-%s, 变量值=%s", mainThreadName, Thread.currentThread().getName(), ttl.get()));
            });

            executorService.execute(() -> {
                sleep(1L);
                System.out.println(String.format("本地变量改变之前(3), 父线程名称-%s, 子线程名称-%s, 变量值=%s", mainThreadName, Thread.currentThread().getName(), ttl.get()));
            });

            executorService.execute(() -> {
                sleep(1L);
                System.out.println(String.format("本地变量改变之前(3), 父线程名称-%s, 子线程名称-%s, 变量值=%s", mainThreadName, Thread.currentThread().getName(), ttl.get()));
            });

            sleep(1L); //确保上面的会在tl.set执行之前执行
            ttl.set(4); // 等上面的线程池第一次启用完了，父线程再给自己赋值

            executorService.execute(() -> {
                sleep(1L);
                System.out.println(String.format("本地变量改变之后(4), 父线程名称-%s, 子线程名称-%s, 变量值=%s", mainThreadName, Thread.currentThread().getName(), ttl.get()));
            });

            executorService.execute(() -> {
                sleep(1L);
                System.out.println(String.format("本地变量改变之后(4), 父线程名称-%s, 子线程名称-%s, 变量值=%s", mainThreadName, Thread.currentThread().getName(), ttl.get()));
            });

            executorService.execute(() -> {
                sleep(1L);
                System.out.println(String.format("本地变量改变之后(4), 父线程名称-%s, 子线程名称-%s, 变量值=%s", mainThreadName, Thread.currentThread().getName(), ttl.get()));
            });

            System.out.println(String.format("线程名称-%s, 变量值=%s", Thread.currentThread().getName(), ttl.get()));

        }).start();

    }

    private static void sleep(long longTime) {
        try {
            Thread.sleep(longTime);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

最终结果如下，线程池中子线程拿到的是父线程中设置的值。
在这里插入图片描述

总结

ThreadLocal 的使用，本身类似于全局变量，而且是可修改的。一旦中间过程被修改，就无法保证整体流程的前后一致性。

应该尽量避免在业务代码中使用的。
Do not use, only when you know why.

参考链接：
1、https://github.com/alibaba/transmittable-thread-local
2、https://zhuanlan.zhihu.com/p/146124826

四问四不知
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ThreadLocal 跨线程传递
weixin_34176694的博客
12-19 1913
2019独角兽企业重金招聘Python工程师标准>>> ...
ThreadLocal
banning的博客
10-16 565
是什么 ThreadLocal提供线程局部变量，如果创建一个ThreadLocal变量，那么访问这个变量的每个线程都会有这个变量的一个副本，在实际多线程操作的时候，操作的是自己本地内存中的变量，从而规避了线程安全问题。ThreadLocal实例通常是类中的私有静态字段。ThreadLocal并不解决线程间共享数据的问题。\color{#FF0000}{ThreadLocal 并不解决线程间共享数据的问题。}ThreadLocal并不解决线程间共享数据的问题。 使用场景 ThreadLocal 适用于变量在线
ThreadLocal在接口参数间传递中的使用
所寫即所思｜一个阿里质量人对测试的所感所悟。
08-12 897
做过接口自动化测试的同学肯定都熟悉在全链路测试过程中，很多业务场景的完成并非由单一接口实现，而是由很多接口组成的一条链路实现。例如你在淘宝上购物场景。不同于单接口测试，这种链路型的接口自动化测试，由于接口间有参数依赖关系，往往不能将链路中的接口入参固定写死，而是要依赖“上游”的响应中的某个字段值，因此需要提取出来动态地传递给下个接口，如下图。解决链路间参数传递的问题可以简化为解决接口间的参数传递问题。当然我上图举例是比较简单的，下游对上游的依赖关系为1对1这种类型。...
Java - ThreadLocal数据存储和传递方式的演变之路
Zong_0915的博客
05-29 1072
我在Java - ThreadLocal原理这篇文章里面主要介绍了的使用、基本原理。仅仅用于单线程内的上下文数据传递。多线程情况下数据隔离。但是现实往往并没有那么简单，我们开发过程中，往往都有多线程的场景。有时候更需要一些变量在多线程中传递。那显然并不满足这样的场景，那么我们来看看它的一个“演变之路”。总结下TTL首先，我们使用的线程池，需要通过进行封装，本质上和单独的任务被封装是一致的。只不过前者更方便了。封装过的任务，也就是存储了当前TTL快照的一个引用。在创建的时候就会捕捉当前父线程中的TTL。
java线程间ThreadLocal的传递
weixin_55891090的博客
03-17 2020
1 场景 本文主要讲解java线程间ThreadLocal的传递。 适用如下场景： （1）线程内new的新的线程，继承父线程的ThreadLocal （2）线程内调用线程池的线程，继承调用线程的ThreadLocall 2 需确认问题 2.1 继承线程的ThreadLocal的含义 新创建的线程，拥有原线程内部的所有的ThreadLocal的配置，和手动配置一遍一样。 2.2 子线程内的ThreadLocal的值和父线程内的有什么关系？ 子线程内被传递的ThreadLocal的值和父线程内的ThreadLo
ThreadLocal跨线程问题
12-22
Java提供了一个特殊的ThreadLocal子类InheritableThreadLocal，它允许线程间的值传递。与普通ThreadLocal不同，InheritableThreadLocal在子线程创建时，会自动将父线程中的值复制过来。这是因为...
threadlocal.rar
07-18
ThreadLocal不是用来解决线程安全问题的，而是为每个线程创建独立的变量副本，确保线程间的变量隔离，避免了线程之间的数据共享和潜在的并发冲突。 ThreadLocal的工作原理可以这样理解：每个ThreadLocal实例都会为...
优雅的使用 ThreadLocal
01-06
Java的 Web项目大部分都是基于 Tomcat，每次访问都是一个新的线程，这样让我们联想到了 ThreadLocal，每一个线程都独享一个 ThreadLocal，在接收请求的时候 set特定内容，在需要的时候 get这个值。下面我们就进入...
java 中ThreadLocal实例分析
08-30
然后，我们创建了三个线程，每个线程都将 ConsumeClientA 实例作为参数传递给 ComsumeThread。最后，我们启动了这三个线程，并观察了线程执行的结果。 结果显示，三个线程都在独立地执行 consume 操作，每个线程都...
使用ThreadLocal在线程间传递参数
LitongZero的博客
09-29 1760
使用ThreadLocal在线程间传递参数 使用场景 用户参数透传，如租户ID，tid，userID，Token等。这些参数与具体业务无关，但是又是必须的（如：租户ID，在数据落库时需要传入，但是在其他业务代码中基本用不到）如果作为方法的参数一层一层向下传递，必然造成代码的冗余和扩展性查等影响。 整片文章就以租户ID为例子说明吧。 1.使用ThreadLocal结合AOP 大致思路：在请求接口时，租户ID往往可以从Token或用户信息中取出，这时，在请求拦截器中，将用户TenantID取出，放入线程中。
Java 源码 - 场景实战：ThreadLocal 在上下文传值场景下的实践
热门推荐
简单记录一下。
10-08 20万+
不啰嗦，我们直接开始！ 开篇语 我们在 《打动面试官：线程池流程编排中的运用实战》一文中将流程引擎简单地完善了一下，本文在其基础上继续进行改造，建议同学可以先看看 GitHub 上的代码，或者看看之前的文章。 1、回顾 流程引擎编排的对象，我们称为组件（就是 SpringBean），之前我们给组件定义了通用的接口，组件实现时就实现这个接口，代码如下： 我们定义了 DomainAbilityBean 接口，入参和出参都是 FlowContent，FlowContent 我们称为上下文。 2、T
ThreadLocal用于传递参数及优势
z394642048的博客
04-08 3730
Threadlocal叫做线程本地变量，也叫线程本地存储，其作用是将参数储存在线程中，然后在该线程运行的任何阶段都能从线程中获取，简单的说，就是起到一个参数传递的作用。 举个具体运用的例子：一般用户在登陆系统之后，我们都会把一个用户的标识信息作为参数放入cookie、或session、或token中，返回给浏览器，然后在以后的请求中，就会带上这个标识信息。当在后续的请...
ThreadLocal使用包括子线程传递实例
AnnotationZZ的博客
04-06 883
1.ThreadLocal的使用主要用于不同线程操作不安全变量时的线程保护 2.ThreadLocal=为Thread提供独有的ThreadLocalMap变量，通过Entry[] table方式存储线程本地变量 3.Thread持有ThreadLocal的引用，所以ThreadLocal需要设置成虚引用避免内存溢出，同时提供删除entry操作避免value值的内存溢出 代码示例 package com.myzy.auth.reetrantlock; public class TestThreadLoca
ThreadLocal父子线程传递数据问题
weixin_44474209的博客
03-05 615
ThreadLocal简介及父子线程间如何传递数据
一文详解ThreadLocal与线程间的数据传递
weixin_43966424的博客
04-08 1784
ThreadLocal、InheritableThreadLocals、TransmittableThreadLocal、MDC在线程间的数据传递详解
并发编程应用——线程池中的ThreadLocal变量传递
你知道的越多，你不知道的越多
11-21 1675
线程池中的ThreadLocal变量传递 ​ 本文讲述下在项目开发过程中遇到的实际问题。 问题 问题描述 ​ 之前搞得项目是SpringCloud开发的微服务项目，用户登录之后把用户信息塞到header里给我们，然后后端统一在网关拦截，读取用户ID然后塞到用户上下文中。但是我们在改造项目的时候发现个问题，莫名其妙的用户信息丢失了 ​ 经过排查，发现是因为SpringCloud的Hystrix隔离策略默认是线程池隔离。 原因分析 ​ 在前面其实有讲过，信号量跟管程都是操作系统的同步互斥方案，那这里Hytrix
微服务之间共享threadlocal_threadlocal跨线程传递解决方案
liuerchong的博客
03-26 7320
ThreadLocal简介 ThreadLocal 不是一个线程，而是一个线程的本地化对象。当某个变量在使用 ThreadLocal 进行维护时，ThreadLocal 为使用该变量的每个线程分配了一个独立的变量副本，每个线程可以自行操作自己对应的变量副本，而不会影响其他线程的变量副本。 API 方法 ThreadLocal 的 API 提供了如下的 4 个方法。 1)protected T initialValue() 返回当前线程的局部变量副本的变量初始值。 2)T get() 返回当前线程的局部变
feign中通过ThreadLocal传递值
最新发布
06-18
Feign 是一个基于 Java 的 HTTP 客户端库，用于与 RESTful 服务进行交互。在 Feign 中，如果需要在请求之间传递数据，通常不推荐直接使用 ThreadLocal，因为 Feign 的请求处理是异步的，每个请求在单独的线程中执行。然而，如果你确实遇到了某种场景需要跨请求共享信息，比如认证令牌，可以考虑以下方法： 1. **使用装饰者模式**：你可以创建一个自定义的 `Interceptor`（拦截器），在每个请求开始前设置 ThreadLocal，然后在拦截器链的回调中获取这个值。 ```java public class MyInterceptor implements ClientRequestInterceptor { private final ThreadLocal<String> threadLocal; public MyInterceptor(String value) { threadLocal = new ThreadLocal<>(); threadLocal.set(value); } @Override public void apply(RequestTemplate requestTemplate) { // 在这里添加你需要的操作，如设置请求头等 // requestTemplate.header("Authorization", threadLocal.get()); } } ``` 使用时，将 `MyInterceptor` 添加到 Feign client 的拦截器列表中： ```java Feign.builder() .client(new OkHttpClient()) .interceptors(Arrays.asList(new MyInterceptor("your_value"))) .target(MyService.class, "http://example.com"); ``` 2. **使用响应拦截器**：对于返回的响应，你也可以设置一个全局的响应拦截器来处理 ThreadLocal 的值。 ```java public class ResponseInterceptor implements ClientResponseInterceptor { @Override public ClientResponse intercept(ClientRequest originalRequest, byte[] originalBody, Response response) { String value = threadLocal.get(); // 对响应进行处理，例如修改响应体或添加头部 return new ClientResponse(response.request(), response.response(), response.headers(), originalBody, new ByteArrayInputStream(response.body())); } } ``` 然后添加到客户端配置： ```java Feign.builder() .client(new OkHttpClient()) .responseInterceptors(Arrays.asList(new ResponseInterceptor())) .target(MyService.class, "http://example.com"); ``` 但是需要注意的是，这种做法可能会导致代码难以理解和维护，因为它绕过了 Feign 的初衷和设计。在大多数情况下，应该优先考虑使用标准的参数传递方式，如请求头、URL 查询参数或请求体。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值