spring boot @Async异步注解上下文透传

《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门，即可获取！方案一：继承线程池，重写相应的方法，透传上下文。方案二：（推荐）线程池ThreadPoolTaskExecutor，有一个TaskDecorator装饰器，实现这个接口，透传上下文。1、ThreadPoolTaskExecutor spring封装的线程池ThreadPoolTaskExecutor

2401_84153193

1062人浏览 · 2024-05-03 22:31:22

2401_84153193 · 2024-05-03 22:31:22 发布

《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门，即可获取！

方案一：

继承线程池，重写相应的方法，透传上下文。

方案二：（推荐）

线程池ThreadPoolTaskExecutor，有一个TaskDecorator装饰器，实现这个接口，透传上下文。

方案一：继承线程池，重写相应的方法，透传上下文。

1、ThreadPoolTaskExecutor spring封装的线程池

ThreadPoolTaskExecutor 线程池代码如下：

https://www.jianshu.com/p/2a58e1df2bbb

@Bean(ExecutorConstant.simpleExecutor_3)

public Executor asyncExecutor3() {

MyThreadPoolTaskExecutor taskExecutor = new MyThreadPoolTaskExecutor();

taskExecutor.setCorePoolSize(corePoolSize);

taskExecutor.setMaxPoolSize(maxPoolSize);

taskExecutor.setQueueCapacity(queueCapacity);

taskExecutor.setThreadNamePrefix(threadNamePrefix_3);

taskExecutor.initialize();

return taskExecutor;

}

//------- 继承父类重写对应的方法 start

class MyCallable implements Callable {

private Callable task;

private RequestAttributes context;

public MyCallable(Callable task, RequestAttributes context) {

this.task = task;

this.context = context;

}

@Override

public T call() throws Exception {

if (context != null) {

RequestContextHolder.setRequestAttributes(context);

}

try {

return task.call();

} finally {

RequestContextHolder.resetRequestAttributes();

}

class MyThreadPoolTaskExecutor extends ThreadPoolTaskExecutor{

@Override

public Future submit(Callable task) {

return super.submit(new MyCallable(task, RequestContextHolder.currentRequestAttributes()));

}

@Override

public ListenableFuture submitListenable(Callable task) {

return super.submitListenable(new MyCallable(task, RequestContextHolder.currentRequestAttributes()));

}

//------- 继承父类重写对应的方法 end

1、MyCallable是继承Callable，创建MyCallable对象的时候已经把Attributes对象赋值给属性context了（创建MyCallable对象的时候因为实在当前主线程创建的，所以是能获取到请求的Attributes），在执行call方法前，先执行了RequestContextHolder.setRequestAttributes(context); 【把这个MyCallable对象的属性context 设置到setRequestAttributes中】所以在执行具体业务时，当前线程（子线程）就能取得主线程的Attributes

2、MyThreadPoolTaskExecutor类是继承了ThreadPoolTaskExecutor 重写了submit和submitListenable方法

为什么是重写submit和submitListenable这两个方法了？

@Async AOP源码的方法位置是在：AsyncExecutionInterceptor.invoke

doSubmit方法能看出来

无返回值调用的是线程池方法：submit()

有返回值，根据不同的返回类型也知道：

返回值类型是：Future.class 调用的是方法：submit()
返回值类型是：ListenableFuture.class 调用的方法是：submitListenable(task)
返回值类型是：CompletableFuture.class调用的是CompletableFuture.supplyAsync这个在异步注解中暂时用不上的，就不考虑重写了。

public Object invoke(final MethodInvocation invocation) throws Throwable {

Class<?> targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null);

Method specificMethod = ClassUtils.getMostSpecificMethod(invocation.getMethod(), targetClass);

final Method userDeclaredMethod = BridgeMethodResolver.findBridgedMethod(specificMethod);

AsyncTaskExecutor executor = determineAsyncExecutor(userDeclaredMethod);

if (executor == null) {

throw new IllegalStateException(

“No executor specified and no default executor set on AsyncExecutionInterceptor either”);

}

Callable task = () -> {

try {

Object result = invocation.proceed();

if (result instanceof Future) {

return ((Future<?>) result).get();

}

catch (ExecutionException ex) {

handleError(ex.getCause(), userDeclaredMethod, invocation.getArguments());

}

catch (Throwable ex) {

handleError(ex, userDeclaredMethod, invocation.getArguments());

}

return null;

};

return doSubmit(task, executor, invocation.getMethod().getReturnType());

}

@Nullable

protected Object doSubmit(Callable task, AsyncTaskExecutor executor, Class<?> returnType) {

if (CompletableFuture.class.isAssignableFrom(returnType)) {

return CompletableFuture.supplyAsync(() -> {

try {

return task.call();

}

catch (Throwable ex) {

throw new CompletionException(ex);

}

}, executor);

}

else if (ListenableFuture.class.isAssignableFrom(returnType)) {

return ((AsyncListenableTaskExecutor) executor).submitListenable(task);

}

else if (Future.class.isAssignableFrom(returnType)) {

return executor.submit(task);

}

else {

executor.submit(task);

return null;

}

2、ThreadPoolExecutor 原生线程池https://www.jianshu.com/p/2a58e1df2bbb

ThreadPoolExecutor线程池代码如下：

//------- ThreadPoolExecutor 继承父类重写对应的方法 start

class MyRunnable implements Runnable {

private Runnable runnable;

private RequestAttributes context;

public MyRunnable(Runnable runnable, RequestAttributes context) {

this.runnable = runnable;

this.context = context;

}

@Override

public void run() {

if (context != null) {

RequestContextHolder.setRequestAttributes(context);

}

try {

runnable.run();

} finally {

RequestContextHolder.resetRequestAttributes();

}

class MyThreadPoolExecutor extends ThreadPoolExecutor{

@Override

public void execute(Runnable command) {

if(!(command instanceof MyRunnable)){

command = new MyRunnable(command,RequestContextHolder.currentRequestAttributes())

}

super.execute(command);

}

public MyThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue workQueue) {

super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);

}

public MyThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue workQueue, ThreadFactory threadFactory) {

super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory);

}

public MyThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue workQueue, RejectedExecutionHandler handler) {

super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, handler);

}

public MyThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler) {

super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, handler);

}

//------- ThreadPoolExecutor 继承父类重写对应的方法 end

像ThreadPoolExecutor主要重写execute方法，在启动新线程的时候先把Attributes取到放到MyRunnable对象的一个属性中，MyRunnable在具体执行run方法的时候，把属性Attributes赋值到子线程中，当run方法执行完了在把Attributes清空掉。

为什么只要重写了execute方法就可以了？

ThreadPoolExecutor大家都知道主要是由submit和execute方法来执行的。

看ThreadPoolExecutor类的submit具体执行方法是由父类AbstractExecutorService#submit来实现。

具体代码在下面贴出来了，可以看到submit实际上最后调用的还是execute方法，所以我们重写execute方法就好了。

submit方法路径及源码：

java.util.concurrent.AbstractExecutorService#submit(java.lang.Runnable)

public Future<?> submit(Runnable task) {

if (task == null) throw new NullPointerException();