我需要记录请求的一些属性,例如请求ID和区域设置,但是当使用parallelStream时,似乎MDC的ThreadLocal会松散信息。
我已经分析了在创建parallelStream时在线程之间传递MDC上下文的解决方案,但是它看起来很脏,并且我也有很多parallelStream的用法。
还有其他方法吗?
谢谢
答案 0 :(得分:0)
我发现的唯一解决方案是将上下文复制到流外部的最终变量中,并将其应用于每个迭代:
Map<String, String> contextMap = MDC.getCopyOfContextMap();
Stream.iterate(0, i -> i + 1).parallel()
.peek(i -> MDC.setContextMap(contextMap))
// ...logic...
// in case you're using a filter, you need to use a predicate and combine it with a clear step:
filter(yourPredicate.or(i -> {
MDC.clear();
return false;
}))
// clear right before terminal operation
.peek(i -> MDC.clear())
.findFirst();
// since the initial thread is also used within the stream and the context is cleared there,
// we need to set it again to its initial state
MDC.setContextMap(contextMap);
该解决方案的成本为1)每100次迭代需要几微秒,并且2)可读性较差,但都可以接受:
IntStream.range(0, 100).parallel().sum()
(=基准)和使用该MDC复制逻辑的相同流的基准:Benchmark Mode Cnt Score Error Units
MDC_CopyTest.baseline thrpt 5 0,038 ± 0,005 ops/us
MDC_CopyTest.withMdc thrpt 5 0,024 ± 0,001 ops/us
MDC_CopyTest.baseline avgt 5 28,239 ± 1,308 us/op
MDC_CopyTest.withMdc avgt 5 40,178 ± 0,761 us/op
public class MDCCopyHelper {
private Map<String, String> contextMap = MDC.getCopyOfContextMap();
public void set(Object... any) {
MDC.setContextMap(contextMap);
}
public void clear(Object... any) {
MDC.clear();
}
public boolean clearAndFail() {
MDC.clear();
return false;
}
}
然后,流式代码看上去会更好一些:
MDCCopyHelper mdcHelper = new MDCCopyHelper();
Optional<Integer> findFirst = Stream.iterate(0, i -> i + 1)
.parallel()
.peek(mdcHelper::set)
// ...logic...
// filters predicates should be combined with clear step
.filter(yourPredicate.or(mdcHelper::clearAndFail))
// before terminal call:
.peek(mdcHelper::clear)
.findFirst();
mdcHelper.set();
答案 1 :(得分:0)
我的解决方案是包装那些功能接口。类似于静态代理模式。
例如
public static void main(String[] args) {
System.err.println(Thread.currentThread().getName());
String traceId = "100";
MDC.put("id", traceId);
System.err.println("------------------------");
Stream.of(1, 2, 3, 4)
.parallel()
.forEach((num -> {
System.err.println(Thread.currentThread().getName()+" "+ traceId.equals(MDC.get("id")));
}));
System.err.println("------------------------");
Stream.of(1, 2, 3, 4)
.parallel()
// the key is the TraceableConsumer
.forEach(new TraceableConsumer<>(num -> {
System.err.println(Thread.currentThread().getName() + " " + traceId.equals(MDC.get("id")));
}));
}
public class TraceableConsumer<T> extends MDCTraceable implements Consumer<T> {
private final Consumer<T> target;
public TraceableConsumer(Consumer<T> target) {
this.target = target;
}
@Override
public void accept(T t) {
setMDC();
target.accept(t);
}
}
public abstract class MDCTraceable {
private final Long id;
private final Long userId;
public MDCTraceable() {
id = Optional.ofNullable(MDC.get("id")).map(Long::parseLong).orElse(0L);
userId = Optional.ofNullable(MDC.get("userId")).map(Long::parseLong).orElse(0L);
}
public void setMDC(){
MDC.put("id", id.toString());
MDC.put("userId", userId.toString());
}
public void cleanMDC(){
MDC.clear();
}
}