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

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

大型超市里，通常都不止一个收银台，因为这样可以提高效率，设想一下，如果某一天，其他的收银员都请假了，只剩下一个收银台，看着那漫长的排队大军，是不是很捉急，很无奈。这就是异步存在的意义了。

当我们需要异步调用的时候，很容易就想到多线程的方式，先创建线程池，然后实现 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 是异步执行的，该思路是生效的。