响应式编程]Context —— ThreadLocal的平替

最新推荐文章于 2025-03-22 13:24:57 发布
最新推荐文章于 2025-03-22 13:24:57 发布
阅读量1.5k 收藏 2
点赞数 2
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BASK2312/article/details/129118845
版权

一、使用介绍

staticStringKEY="TEST_CONTEXT_KEY";
staticStringKEY2="TEST_CONTEXT_KEY2";

publicstaticvoidmain(String[] args) {
	Flux<String> flux = convert("hello", Flux.just(1, 2, 3));
	flux
    	.subscriberContext(Context.of(KEY, "Outside"))
    	.subscribe(v -> System.out.println(v));
}

publicstatic Flux<String> convert(String prefix, Flux<Integer> publisher) {
    return publisher.map(v -> prefix + " " + v)
        .subscriberContext(Context.of(KEY, "NotUsed"))
        .flatMap(v -> Mono.subscriberContext().map(ctx -> ctx.get(KEY) + " " + ctx.get(KEY2) + " " + v))
        .subscriberContext(context -> context.put(KEY2, "Inside"))
        .flatMap(v -> Mono.subscriberContext().map(ctx -> ctx.get(KEY) + " " + v));
}
复制代码

上面是context的使用方案介绍，其输出如下：

Outside Outside Inside hello 1
Outside Outside Inside hello 2
Outside Outside Inside hello 3复制代码

上面的使用案例展示了一个使用context的常见例子。通过在外部方法里传入context，如flux.subscriberContext(Context.of(KEY, "Outside"))，使得内部方法convert能够获取外界环境的context，同时内部方法还可以增加自己的context数据，如subscriberContext(context -> context.put(KEY2, "Inside"))，结合之后，在让内部的方法（flatMap里的方法）感知到整个上下文context的数据内容。

对于context的使用，主要分为几个部分： 1. context的创建 2. context的写入（传入）与读取 3. 执行顺序

1. context —— 不可变对象

由于reactor天然是跨线程的，所以context设计为了不可变的对象，即每次的更新都是创建一个新的对象。每次的put/putAll操作，都是先把旧对象的值复制到新对象，然后再进行put/putAll等更新操作。

2. context的写入与读取

context写入是使用subscriberContext方法，其入参有两种形式：传值方式subscriberContext(ctx)与lambda函数方式 —— subscriberContext(ctx -> ctx.put(key,value))。

context的读取是利用Mono的静态方法subscriberContext()来获取，由于其返回的是一个Mono, 所以通常与flatMap结合使用。

3. 执行顺序

context的传入是发生在subscribe()订阅阶段的，所以其写入的顺序是从下往上的，即在示例中，先执行subscriberContext(Context.of(KEY, "Outside"))，再执行subscriberContext(context -> context.put(KEY2, "Inside")), 最后执行subscriberContext(Context.of(KEY, "NotUsed"))。

在订阅阶段执行完后，进入运行阶段，数据流从上往下执行，每次读取context的时候Mono.subscriberContext()都是读取下一个的context。所以"NotUsed"的context并没有生效。

此外，context.put()操作是复制旧的再update新的对象，所以Mono.subscriberContext().map(ctx -> ctx.get(KEY) + " " + ctx.get(KEY2) + " " + v)这个阶段仍能读取前一个context关于KEY的内容。

总结

  1. context是不可变对象，每次更新都是新的context

  1. context是存在于subscriber的内部的，一个context是绑定在当前subscriber上的，如FluxContextStart的对象

  1. context的写入顺序是从下而上的，读取的时候是从上而下的，只能读取之后的subscriber里的context。

  1. 每个subscriber中的context都是独有的，运行阶段的时候，无法改变其他subscriber的context。

注意

  1. subscriberContext(Context.of("Outside")与subscriberContext(context -> Context.of("Outside"))是有区别，前者是会结合复用前面的context，而后者是直接返回一个新的context并不会复用前面的context。其原因是，subscriberContext(Context.of("Outside")) 其实内部调用的是subscriberContext(context -> context.putAll(Context.of("Outside"))，其入参的context就是前面的context，putAll方法会复用前面的context。而 subscriberContext(context -> Context.of("Outside"))不复用的原因就是因为放弃了入参的context。所以，可以利用这种方式来放弃之前的context，当然不鼓励这么做，因为你不清楚之前context会不会影响后续的程序。

  1. 本文章的代码用的事reactor 3.3的版本，自3.5之后，subscriberContext方法改为contextWrite，读取的方法改为deferContextual。

源码解读

现在我们从源代码上看看，context写入为什么是自下而上的，读取的时候又是依附于下一个subscriber并且自上而下的。

publicfinal Flux<T> subscriberContext(Function<Context, Context> doOnContext) {
	returnnewFluxContextStart<>(this, doOnContext);
}
FluxContextStart(Flux<? extendsT> source, Function<Context, Context> doOnContext) {
	super(source);
	this.doOnContext = Objects.requireNonNull(doOnContext, "doOnContext");
}

@Overridepublic CoreSubscriber<? super T> subscribeOrReturn(CoreSubscriber<? super T> actual) {
    Contextc= doOnContext.apply(actual.currentContext());
    returnnewContextStartSubscriber<>(actual, c);
}
ContextStartSubscriber(CoreSubscriber<? super T> actual, Context context) {
    this.actual = actual;
    this.context = context;
    if (actual instanceof ConditionalSubscriber) {
        this.actualConditional = (ConditionalSubscriber<? super T>) actual;
    }
    else {
        this.actualConditional = null;
    }
}
@Overridepublic Context currentContext() {
    returnthis.context;
}
复制代码

上面截取了subscriberContext方法的源代码，可以看到subscriberContext方法最终会创建ContextStartSubscriber的对象，并将生成的context赋值Context c = doOnContext.apply(actual.currentContext())，所以context是伴随subscriberContext方法对应的subscriber里的。

由于context赋值操作Context c = doOnContext.apply(actual.currentContext())是发生在subscribeOrReturn方法里，即发生在subscribe()订阅阶段，所以整个执行的顺序是自下而上的（沿着整个flow自下而上至源头的publisher）。

那读取context的时候为什么是自上而下的呢？我们来看下读取操作Mono.subscribeContext()的源码。

publicstatic Mono<Context> subscriberContext() {
    return onAssembly(MonoCurrentContext.INSTANCE);
}
finalclassMonoCurrentContextextendsMono<Context>
		implementsFuseable, Scannable {
	staticfinalMonoCurrentContextINSTANCE=newMonoCurrentContext();
	publicvoidsubscribe(CoreSubscriber<? super Context> actual) {
		Contextctx= actual.currentContext();
		actual.onSubscribe(Operators.scalarSubscription(actual, ctx));
	}
}
interfaceInnerOperator<I, O>
		extendsInnerConsumer<I>, InnerProducer<O> {
	@Override
	default Context currentContext() {
		return actual().currentContext();
	}
}
复制代码

Mono.subscribeContext()方法返回的是一个MonoCurrentContext的静态对象，在订阅subscribe时期，就会去读取当前的context，即Context ctx = actual.currentContext()。而对于一个InnerOperator的接口而言，其currentContext()方法会不断寻找下一个subscriber的context，即 actual().currentContext(),直到有哪个subscriber覆写了currentContext方法，如先前的ContextStartSubscriber对象。对于InnerOperator接口，是大多数subscriber都会实现的接口，例如map、filter、flatmap这些，都会实现这个接口。

在找到context之后，通过Operators.scalarSubscription(actual, ctx)写入，这个方法其实也是Mono.just()的实现，所以相当于把context当做value，生成了一个Mono.just(ctx)来完成了context读取。

所以，context读取的是从当前操作operator之后的那个最接近的subscriber的context。这也解释了前面使用案例中，subscriberContext(Context.of(KEY, "NotUsed"))，没有作用的缘故。

三、如何桥接现有的ThreadLocal系统

虽然reactor提供了context来替代ThreadLocal的使用，但目前大多数的代码库仍然是命令式编程的，使用的方式仍然是基于ThreadLocal的，如Logger里的MDC。本小节以Logger中的MDC来介绍，如何利用context实现与旧系统中的基于ThreadLocal方式的打通。

我们假设有这样的一个场景，每一次的Http请求都有一个trace id，我们称为request id，并通过Http Header "X-Request-Id"来命名，打印日志的时候，希望每条日志里都包含请求id，这样方便跟踪整个请求链路的情况。

为此，我们把日志配置里的pattern设置为：[%X{X-Request-Id}] [%thread] %-5level - %msg %n。

可以在SpringBoot的application.yml里设置，如：

logging.pattern.level: "[%X{X-Request-Id}] [%thread] %-5level - %msg %n"复制代码

因此，要使得每条日志里有request id，那就必须要MDC里有key为X-Request-Id的内容。下面来看下，reactor中是如何实现的。

@SpringBootApplication@Slf4j@RestControllerpublicclassMdcApplication {

  publicstaticvoidmain(String[] args) {
    SpringApplication.run(MdcApplication.class, args);
  }

  privatefinalstaticStringX_REQUEST_ID_KEY="X-Request-Id";

  @GetMapping("/")
  Flux<String> split(@RequestParam("value") String value, @RequestHeader(X_REQUEST_ID_KEY) String requestId) {
    return Flux.fromArray(value.split("_"))
        .doOnEach(logWithContext(ch -> log.info("handling one item: {}", ch)))
        .subscriberContext(Context.of(X_REQUEST_ID_KEY, requestId));
  }

  privatestatic <T> Consumer<Signal<T>> logWithContext(Consumer<T> logStatement) {
    return signal -> {
      if (!signal.isOnNext()) {
        return;
      }
      StringrequestId= signal.getContext().get(X_REQUEST_ID_KEY);
      try (MDC.MDCCloseablecloseable= MDC.putCloseable(X_REQUEST_ID_KEY, requestId)) {
        logStatement.accept(signal.get());
      }
    };
  }
}
复制代码

这是一个简单的示例程序，对于请求输入的value值通过"-"分割后，再一个个返回给客户端。首先利用subscriberContext方法，将http header里的X-Request-Id作为context来传入。然后利用doOnEach的方式获取signal。doOnEach的方法可以工作在onNext、onComplete、onError等所有事件，每一个信号signal里都包含有context，当为onNext则还包含value值，当为onError时，则还包含有exception。因此可以通过signal来获取context。

在从context获取X-Request-Id后，可以利用try-with-resource方式来更新MDC，其效果是在执行完try里面的程序后，将更新的value回退。等价于：

try {
	MDC.put(X_REQUEST_ID_KEY, requestId);
	logStatement.accept(signal.get());
} finally {
	MDC.remove(X_REQUEST_ID_KEY);
}
复制代码

置于为什么需要操作完之后回退掉MDC中的更新，那是因为reactor中所有的操作都是异步执行在不同线程中的，如果不回退的话，很有可能造成污染，其原因还是MDC内部是用ThreadLocal实现的，所以跨线程的时候，如果不把ThreadLocal值清理干净，很容易造成互相污染。

用curl命令发送请求：curl --header "X-Request-Id:12345" localhost:8080?value=a_b_c，返回的结果是abc，打印的日志如下：

[12345] [reactor-http-nio-2] INFO  - handling one item: a 
[12345] [reactor-http-nio-2] INFO  - handling one item: b 
[12345] [reactor-http-nio-2] INFO  - handling one item: c 
复制代码

其中12345就是从context里获取到的request id。

如果想要将request id继续贯穿后续请求流程，如请求第三方服务，可以在用webClient发送请求的时候，把request id作为header加入到它的request请求里，如:

Mono.subscriberContext().map(ctx -> {   
    RequestHeadersSpec<?> request = webClient.get().uri(uri);       
    request = request.header("X-Request-ID", ctx.get(X_REQUEST_ID_KEY)); 
    // The rest of your request logic...    
});
复制代码

四、总结

本文介绍了reactor中context的概念，并用代码示例的方式介绍了如何使用。再然后，通过源码的解读来加深对context使用规则的理解：自下而上的context写入，以及与subscriber绑定后的自上而下的读取。 在这之后，用以传递并打印日志中包含request id的一个实际例子，来介绍如何使用context与log的MDC一起使用。

虽然reactor自3.1开始提供了context来弥补无法使用ThreadLocal的不足，但与ThreaLocal相比，context仍然有不少局限。比如使用上的不方便，要么利用Mono.subscribeContext().map并搭配flatmap来使用，要么需要将数据流转化成信号signal流来使用，总之远不如ThreadLocal来的简单易用。另外，context的不可变特性，虽然有助于thread safe，但使得不同方法之间无法传递更新，比如方法A内修改后再传递给方法B，因为context是只读的，但这在ThreadLocal上却是轻而易举就能实现。

好消息的是，reactor在3.5开始，提供了新的方法deferContextual来简化context的使用。以及提出了context view的概念来简化context传递问题，感兴趣的可以阅读reactor文档。

作者：临虹路365号

链接：https://juejin.cn/post/7201084288523452476

Random 高并发下的缺点(美团面试题) 替代方案JUC下的 ThreadLocalRandom
小驴
08-07 750
Random 高并发下的缺点 大量CAS导致CPU飙高 Random random = new Random(); System.out.println(random.nextInt(100)); 一、奇怪的命名 random.nextInt() 奇怪的命名,获取值为什么不是通常的 “get”, “create”，“generate”等常见的命名.random生成的随机数，并不是真正的随机，它有一个种子的概念，是根据种子值来计算【下一个】值的，如果种子值相同，那么它生成出来的随机数也必定相等，也
响应式编程（一）
weixin_50458070的博客
01-21 1115
Reactor 是一个用于JVM的完全非阻塞的响应式编程框架，具备高效的需求管理（即对 “背压（backpressure）”的控制）能力。它提供了异步序列 API Flux（用于[N]个元素）和 Mono（用于 [0|1]个元素），并完全遵循和实现了“响应式扩展规范”（Reactive Extensions Specification）。Reactor 的 reactor-ipc 组件还支持非阻塞的进程间通信（inter-process communication, IPC）。
聊聊reactor异步线程的变量传递
liuhyusb的博客
01-22 476
本文主要研究下reactor异步线程的变量传递。
ThreadLocal 参数传递全解析：实现线程内数据共享的实用指南
最新发布
lssffy的博客
03-22 1175
的参数传递是多线程开发中的实用技能，无论是同一线程内的自然传递，还是线程池和跨线程的显式管理，掌握这些方法将帮助你在2025年的项目中轻松应对复杂场景。
在Netty中使用FastThreadLocal代替ThreadLocal
TheOne的博客
03-30 742
FastThreadLocal相比较于ThreadLocal在FastThreadLocalThread有更好的表现，因为在FastThreadLocal是使用数组而不是像ThreadLocal那样使用hash code 以及hash table去查找对象。尽管看起来非常微妙，但它比使用哈希表产生了一些性能优势，并且在频繁访问时非常有用。 为了使用FastThreadLocal带来的优势，你的线程类型应该使用FastThreadLocal以及它的子类，而不是使用Thread(下面会讲到原因)。因此在Net
原来这就是比 ThreadLocal 更快的玩意
yes
09-07 287
你好，我是yes。 继上一篇之后，咱们再来盘一盘 FastThreadLocal ，这个算是 ThreadLocal 的进阶版，是 Netty 针对 ThreadLocal 自己造的轮子，所以对 ThreadLocal 没有完全理解的话，建议先看上一篇文章，打个基础。 那了解 FastThreadLocal 之后呢，对平日的一些优化可能可以提供一些思路，或者面试就能装个x。 面试官：ThreadLocal 竟然有xxx这个缺点，那怎么优化啊？ 你就把 FastThreadLocal 的实现 BB 一遍，这不
ThreadLocal不宜在线程池中使用，及代替方法
djdjdndjs的博客
04-29 689
ThreadLocal是用来在多线程中隔离变量的，但是在线程池中会有取值错误的问题可以使用来进行代替。
这玩意比ThreadLocal叼多了，吓得why哥赶紧分享出来。
qq_27243343的博客
10-19 634
这是why哥的第 70 篇原创文章 从Dubbo的一次提交开始 故事得从前段时间翻阅 Dubbo 源码时，看到的一段代码讲起。 这段代码就是这个： org.apache.dubbo.rpc.RpcContext 使用 InternalThreadLocal 提升性能。 相信作为一个程序猿，都会被 improve performance（提升性能）这样的字眼抓住眼球。 心里开始痒痒的，必须要一探究竟。 刚看到这段代码的时候，我就想：既然他是要提升性能，那说明之前的东西表现的不太好。 那之前的东西是什么？
Spring源码——Spring MVC
等一杯咖啡的博客
11-22 1768
前言 内容主要参考自《Spring源码深度解析》一书，算是读书笔记或是原书的补充。进入正文后可能会引来各种不适，毕竟阅读源码是件极其痛苦的事情。 本文主要涉及书中第十一章的部分，依照书中内容以及个人理解对Spring源码进行了注释，详见Github仓库：https://github.com/MrSorrow/spring-framework Spring框架提供了构建Web应用程序的全功能MVC模...
webflux 使用threadlocal
01-10
### 如何在 Spring WebFlux 中安全地...需要注意的是，尽管有办法让 `ThreadLocal` 在特定条件下适用于响应式编程模型，但这通常不是推荐的做法。尽可能利用框架本身提供的工具集来解决问题往往更加高效且不易出错。
全面解读Spring Cloud Zuul：从配置到优化的实战指南
热门推荐
张彦峰的博客
02-14 168万+
在微服务架构中，API网关作为核心组件之一，承担着请求路由、负载均衡、安全认证等重要功能。Spring Cloud Zuul作为一款功能强大的API网关解决方案，得到了广泛应用。本文将深入探讨Spring Cloud Zuul的各项功能，从基础配置到工作原理，再到多层负载和应用优化，全面解析其在实际应用中的最佳实践与实用技巧，为开发者提供一站式指导，助力其打造高性能、高可用的微服务架构。
如何为Apache JMeter开发插件（四）——几种类型的Sampler
一个测试工程师的代码世界
09-09 1万+
JavaSamplerClient、JUnit Sampler和脚本化Sampler的开发指南
ThreadLocal详解
wyaoyao93的博客
04-10 268
文章目录1 线程上下文设计2 ThreadLocal2.1 ThreadLocal的使用场景及注意事项2.2 ThreadLocal的方法详解及源码分析2.2.1 简单认识2.2.2 常用方法initialValueset方法get方法2.2.3 ThreadLocalMapThreadLocal的内存泄漏问题分析 1 线程上下文设计 单个线程执行的任务步骤会非常多，后一个步骤的输入有可能是前一个步骤的输出，比如在单个线程多步骤（阶段）执行时，为了使得功能单一，有时候我们会采用GoF职责链设计模式：
ThreadLocal取代每次都从session中获取登录用户信息
yanlzhl的博客
06-12 9822
方式一：直接使用JDK中ThreadLocal方式 1.先定义一个存放登录用户信息的实体类，并在这里面操纵用户信息 public class UserContext implements Serializable{ private static ThreadLocal loginEntityThreadLocal=new ThreadLocal public stati
MtContextThreadLocal（一）
qianxc88的专栏
06-29 1051
AtomicReference干嘛的？ 假设releaseMtContextAfterRun为true,那么上下文仅能被执行线程使用一次。 所以@Override public void run() { Map<MtContextThreadLocal<?>, Object> copied = copiedRef.get(); if (copied == null || rele
ThreadLocalRandom替换Random
meser88的博客
05-14 251
前言 最近在写一些业务代码时遇到一个需要产生随机数的场景，这时自然想到 jdk 包里的Random类。 但出于对性能的极致追求，就考虑使用ThreadLocalRandom类进行优化，在查看 ThreadLocalRandom 实现的过程中，又追了下Unsafe有部分代码，整个流程下来，学到了不少东西，也通过搜索和提问解决了很多疑惑，于是总结成本文。 Random 的性能问题 使用 Random 类时，为了避免重复创建的开销，我们一般将实例化好的 Random 对象设置为我们所使用服务对象...
java之struts2的ThreadLocal和ActionContext
weixin_33871366的博客
06-03 115
在之前的学习中，我们知道struts2可以将表单中的数据自动设置到处理类的属性上，还有类型转换等其他功能。那么struts2是怎样做这件事情的呢？ struts2完成这些功能是通过拦截器来完成的，并且在这个过程中数据进行迁移的动作，数据从request对象中迁移到了处理类上。完成数据迁移是由ActionContext来完成的。 1.先学习下ThreadLocal 这个类提供了线程局部(thr...
Thread代替引用传递，利用ThreadLocal来为每一个线程保留自己的空间
lyflyyvip的博客
08-24 1306
ThreadLocal代替引用传递，为每一个线程保留自己的空间。
Java并发工具类 - ThreadLocal
Lupu's journey - 生活、分享
08-04 494
1. ThreadLocal概念 ThreadLocal用于线程间的数据隔离。应用场合，最适合的是按线程多实例（每个线程对应一个实例）的对象的访问，并且这个对象很多地方都要用到。 ThreadLocal是一个本地线程副本变量工具类。当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值