Hystrix 线程隔离：线程池位置与跨线程上下文传递解析
Hystrix 的线程隔离是通过在调用方服务中维护独立线程池实现的，其核心目的是将不同依赖服务的调用隔离开，避免单个依赖的故障耗尽调用方的线程资源。同时，线程隔离会引入跨线程问题（如ThreadLocal上下文丢失），需通过自定义并发策略解决。
Hystrix 线程池的存在位置
Hystrix 的线程池存在于调用方服务（消费端） 中，由调用方为每个依赖的服务（或服务分组）维护一个独立的线程池。
例如：服务 A 调用服务 B 和服务 C，服务 A 会为服务 B 创建线程池 B，为服务 C 创建线程池 C。当服务 B 响应超时或故障时，线程池 B 的线程可能被耗尽，但线程池 C 仍能正常处理对服务 C 的调用，从而实现 “故障隔离”。
为什么线程池在调用方？
- 线程隔离的核心是保护调用方的资源不被依赖服务耗尽，因此线程池必须由调用方控制和维护；
- 若线程池在服务提供方，调用方仍可能因等待响应而耗尽自身线程，无法实现隔离目的。
跨线程上下文丢失问题：ThreadLocal 的 “陷阱”
问题场景
Web 应用中，RequestContextHolder通过ThreadLocal存储请求上下文（如用户登录信息、请求头），但 Hystrix 命令在独立线程池的线程中执行，与 Tomcat 的工作线程（主线程）属于不同线程，导致RequestContextHolder.getRequestAttributes()返回null。
原因：ThreadLocal的特性是 “线程私有”，主线程的ThreadLocal数据无法自动传递到 Hystrix 命令执行的子线程。
解决方案：自定义 HystrixConcurrencyStrategy
Hystrix 提供HystrixConcurrencyStrategy接口，允许通过 “装饰器模式” 扩展线程执行逻辑，实现跨线程的上下文传递。核心思路是：在主线程中捕获上下文，在子线程执行时恢复上下文。
1. 自定义并发策略实现
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
| public class CustomHystrixConcurrencyStrategy extends HystrixConcurrencyStrategy {
private final HystrixConcurrencyStrategy delegate;
public CustomHystrixConcurrencyStrategy() {
this.delegate = HystrixPlugins.getInstance().getConcurrencyStrategy();
HystrixPlugins.getInstance().registerConcurrencyStrategy(this);
}
@Override
public <T> Callable<T> wrapCallable(Callable<T> callable) {
RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
return new WrappedCallable<>(callable, requestAttributes);
}
@Override
public ThreadPoolExecutor getThreadPool(HystrixThreadPoolKey threadPoolKey, HystrixThreadPoolProperties properties) {
return delegate.getThreadPool(threadPoolKey, properties);
}
@Override
public BlockingQueue<Runnable> getBlockingQueue(int maxQueueSize) {
return delegate.getBlockingQueue(maxQueueSize);
}
private static class WrappedCallable<T> implements Callable<T> {
private final Callable<T> target;
private final RequestAttributes requestAttributes;
public WrappedCallable(Callable<T> target, RequestAttributes requestAttributes) {
this.target = target;
this.requestAttributes = requestAttributes;
}
@Override
public T call() throws Exception {
try {
RequestContextHolder.setRequestAttributes(requestAttributes);
return target.call();
} finally {
RequestContextHolder.resetRequestAttributes();
}
}
}
}
|
2. 策略生效原理
Hystrix 在执行命令时，会通过HystrixContextRunnable包装任务，其初始化过程确保了wrapCallable在主线程中被调用：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
| public class HystrixContextRunnable implements Runnable {
private final Callable<Void> actual;
private final HystrixRequestContext parentThreadState;
public HystrixContextRunnable(Runnable actual) {
this.actual = HystrixPlugins.getInstance().getConcurrencyStrategy()
.wrapCallable(() -> { actual.run(); return null; });
this.parentThreadState = HystrixRequestContext.getContextForCurrentThread();
}
@Override
public void run() {
HystrixRequestContext existingState = HystrixRequestContext.getContextForCurrentThread();
try {
HystrixRequestContext.setContextOnCurrentThread(parentThreadState);
actual.call();
} catch (Exception e) {
throw new RuntimeException(e);
} finally {
HystrixRequestContext.setContextOnCurrentThread(existingState);
}
}
}
|
- 时机保证：
HystrixContextRunnable在主线程中初始化，此时调用wrapCallable可成功获取RequestAttributes；
- 跨线程传递：
WrappedCallable在子线程执行时，通过RequestContextHolder.setRequestAttributes恢复上下文，实现ThreadLocal数据的传递。
3. 启用自定义策略
在 Spring Boot 应用中，通过@Bean注册自定义策略即可生效：
1
2
3
4
5
6
7
| @Configuration
public class HystrixConfig {
@Bean
public CustomHystrixConcurrencyStrategy customHystrixConcurrencyStrategy() {
return new CustomHystrixConcurrencyStrategy();
}
}
|
总结
- 线程池位置：Hystrix 的线程池存在于调用方服务（消费端），为每个依赖服务维护独立线程池，实现故障隔离；
- 跨线程上下文问题：因
ThreadLocal的线程私有特性，主线程的RequestContextHolder上下文无法直接传递到 Hystrix 的子线程；
- 解决方案：通过自定义
HystrixConcurrencyStrategy，在wrapCallable方法中捕获主线程上下文，在子线程执行时恢复，确保跨线程的上下文传递
v1.3.10