# spring boot 自定义线程池进行异步调用

关注
发布于: 2020 年 08 月 08 日
﻿大型超市里，通常都不止一个收银台，因为这样可以提高效率，设想一下，如果某一天，其他的收银员都请假了，只剩下一个收银台，看着那漫长的排队大军，是不是很捉急，很无奈。这就是异步存在的意义了。
﻿
当我们需要异步调用的时候，很容易就想到多线程的方式，先创建线程池，然后实现 Runnable 或者 Callable 接口来创建对象，然后将对象放在线程池中去执行。除了这个，spring 提供了更简单粗暴的方式，这就是本章的主角： @Async 。
﻿
如果直接使用 @Async，那么默认就是使用 SimpleAsyncTaskExecutor 线程池，由于 SimpleAsyncTaskExecutor 不限制并发线程而且不重用线程，那么直接使用是有风险的，所以本章直接介绍通过自定义线程池来使用 @Async 达到异步调用的目的。
﻿
1. 创建默认线程池
@EnableAsync
@Configuration
public class ThreadPoolConfig {
    @Bean("taskExecutor")
    public Executor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(16);
        executor.setMaxPoolSize(16);
        executor.setQueueCapacity(1024);
        executor.setKeepAliveSeconds(60);
        executor.setThreadNamePrefix("taskExecutor-");
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        return executor;
    }
}
﻿
@EnableAsync 注解主要是为了扫描范围包下的所有 @Async 注解
﻿
2.创建异步任务类﻿
@Component
public class AsyncTask {
    /**
     * task 1
     */
    @Async("taskExecutor")
    public void task1() {
        System.out.println("task1 开始执行");
        long startTime = System.currentTimeMillis();
        try {
            Thread.sleep(1000L);
        } catch (InterruptedException e) {
        }
        System.out.println("task1 执行结束，耗时：" + (System.currentTimeMillis() - startTime));
    }
    /**
     * task 1
     */
    @Async("taskExecutor")
    public void task2() {
        System.out.println("task2 开始执行");
        long startTime = System.currentTimeMillis();
        try {
            Thread.sleep(1000L);
        } catch (InterruptedException e) {
        }
        System.out.println("task2 执行结束，耗时：" + (System.currentTimeMillis() - startTime));
    }
}
﻿
3.异步调用类﻿
@RestController
public class AsyncController {
    @Autowired
    private AsyncTask asyncTask;
    @GetMapping("/async")
    public void test(){
        System.out.println("test 开始执行");
        long startTime = System.currentTimeMillis();
        asyncTask.task1();
        asyncTask.task2();
        System.out.println("test 执行结束，耗时：" + (System.currentTimeMillis() - startTime));
    }
}
﻿
打印结果：
﻿
test 开始执行
test 执行结束，耗时：6
task1 开始执行
task2 开始执行
task1 执行结束，耗时：1000
task2 执行结束，耗时：1000
﻿
4.有返回值的异步任务﻿
以上的 task1 和 task2 任务是没有返回值，如果碰到需要获取任务结果怎么办，这时候就可以用到 Future 了。
﻿
先给 task1 和 task2 添加返回值：
﻿
/**
     * task 1
     */
@Async("taskExecutor")
public Future<String> task1() {
    System.out.println("task1 开始执行");
    long startTime = System.currentTimeMillis();
    try {
        Thread.sleep(1000L);
    } catch (InterruptedException e) {
    }
    System.out.println("task1 执行结束，耗时：" + (System.currentTimeMillis() - startTime));
    return new AsyncResult<>("task1 success");
}
/**
     * task 2
     */
@Async("taskExecutor")
public Future<String> task2() {
    System.out.println("task2 开始执行");
    long startTime = System.currentTimeMillis();
    try {
        Thread.sleep(1000L);
    } catch (InterruptedException e) {
    }
    System.out.println("task2 执行结束，耗时：" + (System.currentTimeMillis() - startTime));
    return new AsyncResult<>("task2 success");
}
﻿
然后进行调用，并获取结果：
﻿
@GetMapping("/async")
    public void test() throws ExecutionException, InterruptedException {
        System.out.println("test 开始执行");
        long startTime = System.currentTimeMillis();
        Future<String> result1 = asyncTask.task1();
        Future<String> result2 = asyncTask.task2();
        System.out.println("test 执行结果，result1：" + result1.get() + ", result2:" + result2.get());
        System.out.println("test 执行结束，耗时：" + (System.currentTimeMillis() - startTime));
    }
﻿
打印结果如下：
﻿
test 开始执行
task1 开始执行
task2 开始执行
task1 执行结束，耗时：1001
task2 执行结束，耗时：1001
test 执行结果，result1：task1 success, result2:task2 success
test 执行结束，耗时：1016
﻿
可以看到 task1 和 task2 是异步执行的，并且成功获取到返回结果。
5.注意事项﻿
如果将在异步任务类中直接调用 @Async 修饰的方法，那么异步调用将会失效。
﻿
举个栗子：在 AsyncTask 类中直接调用 task1 和 task2 方法：
﻿
public void test(){
    System.out.println("test 开始执行");
    long startTime = System.currentTimeMillis();
    this.task1();
    this.task2();
    System.out.println("test 执行结束，耗时：" + (System.currentTimeMillis() - startTime));
}
﻿
然后在 AsyncController 中调用 test 方法：
﻿
@GetMapping("/async")
public void test(){
     asyncTask.test();
}
﻿
打印结果如下：
﻿
test 开始执行
task1 开始执行
task1 执行结束，耗时：1000
task2 开始执行
task2 执行结束，耗时：1001
test 执行结束，耗时：2001
﻿
可以明显看出，task1 和 task2 不是异步执行的。原因就是调用 task1 和 task2 方法的是 AsyncTask 对象本身，而不是 spring 启动的时候为其创建的代理对象，没有经过 spring 容器。如果要解决这个问题，就按照这个思路，创建一个代理对象即可。
﻿
在 AsyncTask 中先通过自动装配获取 applicationContext 对象，然后通过 applicationContext 获取 AsyncTask 的代理对象，通过代理对象来调用 task1 和 task2 ：
﻿
@Component
public class AsyncTask {
    @Autowired
    private ApplicationContext applicationContext;
    public void test(){
        System.out.println("test 开始执行");
        long startTime = System.currentTimeMillis();
        applicationContext.getBean(AsyncTask.class).task1();
        applicationContext.getBean(AsyncTask.class).task2();
        System.out.println("test 执行结束，耗时：" + (System.currentTimeMillis() - startTime));
    }
    /**
     * task 1
     */
    @Async("taskExecutor")
    public Future<String> task1() {
        System.out.println("task1 开始执行");
        long startTime = System.currentTimeMillis();
        try {
            Thread.sleep(1000L);
        } catch (InterruptedException e) {
        }
        System.out.println("task1 执行结束，耗时：" + (System.currentTimeMillis() - startTime));
        return new AsyncResult<>("task1 success");
    }
    /**
     * task 2
     */
    @Async("taskExecutor")
    public Future<String> task2() {
        System.out.println("task2 开始执行");
        long startTime = System.currentTimeMillis();
        try {
            Thread.sleep(1000L);
        } catch (InterruptedException e) {
        }
        System.out.println("task2 执行结束，耗时：" + (System.currentTimeMillis() - startTime));
        return new AsyncResult<>("task2 success");
    }
}
﻿
调用方法：
﻿
@GetMapping("/async")
public void test() throws ExecutionException, InterruptedException {
    System.out.println("test 开始执行");
    asyncTask.test();
    long startTime = System.currentTimeMillis();
    System.out.println("test 执行结束，耗时：" + (System.currentTimeMillis() - startTime));
}
打印结果：
﻿
test 开始执行
test 开始执行
test 执行结束，耗时：6
test 执行结束，耗时：0
task1 开始执行
task2 开始执行
task1 执行结束，耗时：1000
task2 执行结束，耗时：1000
可以看到 task1 和 task2 是异步执行的，该思路是生效的。
﻿
发布于: 2020 年 08 月 08 日阅读数: 110
原文链接:【http://xie.infoq.cn/article/67174901ae960b4083cab0606】。
方明

关注
不求有多辉煌，但求无愧过往 2019.02.15 加入
Java 后端，没事侃侃
发布
暂无评论
创作场景

# spring boot 自定义线程池进行异步调用

﻿

1. 创建默认线程池

2.创建异步任务类

3.异步调用类

4.有返回值的异步任务

5.注意事项

方明

评论
