SpringBoot多线程异步任务：ThreadPoolTaskExecutor + CompletableFuture

﹏ヽ暗。殇╰゛Y 2023-10-12 19:29 59阅读 0赞

## 1. SpringBoot多线程异步任务 ##

### 1.1. 需求 ###

在 `SpringBoot` 项目中，一个任务比较复杂，执行时间比较长，需要采用 `多线程异步` 的方式执行，从而缩短任务执行时间。

### 1.2. 多线程异步 ###

1.  将任务拆分成多个独立的子任务，每个子任务在独立子线程中执行；
2.  当所有子任务的子线程全部执行完成后，将几个子任务汇总，得到总任务的执行结果。

*  非阻塞：在汇总子任务时，不会阻塞主线程，也就是说汇总任务，也是在子线程执行的。开启了执行子任务和执行汇总任务的线程后，主线程就继续向下执行了。
 *  阻塞：在汇总子任务时，阻塞主线程，等待所有子任务执行完成并且汇总后，程序才继续向下执行。

## 2. 解决方案 ##

> `ThreadPoolTaskExecutor` \+ `CompletableFuture`

ThreadPoolTaskExecutor：是Spring框架提供的。  
CompletableFuture：是 java 提供的（Java8 及以上）。

## 3. 代码实现 ##

### 3.1. 异步任务和同步任务 ###

package com.example.async.service;
    
    import java.util.concurrent.CompletableFuture;
    import java.util.concurrent.ExecutionException;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
    import org.springframework.stereotype.Service;
    
    @Service
    public class TaskService {
        
    
    	@Autowired
    	private ThreadPoolTaskExecutor executor;
    
    	public void executeAsyncNonBlocking() {
        
    		System.out.println("----------执行异步任务（非阻塞），开始----------");
    
    		long start = System.currentTimeMillis();
    		CompletableFuture<Void> task1Future = CompletableFuture.runAsync(() -> {
        
    			task1();
    		}, executor);
    
    		CompletableFuture<Void> task2Future = CompletableFuture.runAsync(() -> {
        
    			task2();
    		}, executor);
    
    		CompletableFuture<Void> task3Future = CompletableFuture.runAsync(() -> {
        
    			task3();
    		}, executor);
    
    		CompletableFuture.allOf(task1Future, task2Future, task3Future).thenRun(() -> {
        
    			System.out.println("----------执行所有异步任务，结束----------");
    			System.out.println("执行时间：" + (System.currentTimeMillis() - start) + " 毫秒");
    		});
    
    		System.out.println("----------执行异步任务（主线程），结束----------");
    		System.out.println("执行时间：" + (System.currentTimeMillis() - start) + " 毫秒");
    	}
    
    	/**
    	 * 执行异步任务
    	 * 
    	 * @throws ExecutionException
    	 * @throws InterruptedException
    	 */
    	public void executeAsync() throws InterruptedException, ExecutionException {
        
    		System.out.println("----------执行异步任务，开始----------");
    
    		long start = System.currentTimeMillis();
    		CompletableFuture<Void> task1Future = CompletableFuture.runAsync(() -> {
        
    			task1();
    		}, executor);
    
    		CompletableFuture<Void> task2Future = CompletableFuture.runAsync(() -> {
        
    			task2();
    		}, executor);
    
    		CompletableFuture<Void> task3Future = CompletableFuture.runAsync(() -> {
        
    			task3();
    		}, executor);
    
    		CompletableFuture.allOf(task1Future, task2Future, task3Future).get();
    
    		long end = System.currentTimeMillis();
    
    		System.out.println("----------执行异步任务，结束----------");
    		System.out.println("执行时间：" + (end - start) + " 毫秒");
    	}
    
    	/**
    	 * 执行同步任务
    	 */
    	public void executeSync() {
        
    		System.out.println("----------执行同步任务，开始----------");
    
    		long start = System.currentTimeMillis();
    		task1();
    		task2();
    		task3();
    		long end = System.currentTimeMillis();
    
    		System.out.println("----------执行同步任务，结束----------");
    		System.out.println("执行时间：" + (end - start) + " 毫秒");
    	}
    
    	private void task1() {
        
    		try {
        
    			System.out.println("task1 开始");
    			long start = System.currentTimeMillis();
    			Thread.sleep(1000);
    			long end = System.currentTimeMillis();
    			System.out.println("task1 结束，执行时间：" + (end - start) + " 毫秒");
    		} catch (InterruptedException e) {
        
    			throw new RuntimeException(e);
    		}
    	}
    
    	private void task2() {
        
    		try {
        
    			System.out.println("task2 开始");
    			long start = System.currentTimeMillis();
    			Thread.sleep(2000);
    			long end = System.currentTimeMillis();
    			System.out.println("task2 结束，执行时间：" + (end - start) + " 毫秒");
    		} catch (InterruptedException e) {
        
    			throw new RuntimeException(e);
    		}
    	}
    
    	private void task3() {
        
    		try {
        
    			System.out.println("task3 开始");
    			long start = System.currentTimeMillis();
    			Thread.sleep(3000);
    			long end = System.currentTimeMillis();
    			System.out.println("task3 结束，执行时间：" + (end - start) + " 毫秒");
    		} catch (InterruptedException e) {
        
    			throw new RuntimeException(e);
    		}
    	}
    
    }

### 3.2. 执行任务（异步任务和同步任务） ###

package com.example.async.controller;
    
    import java.util.concurrent.ExecutionException;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import com.example.async.service.TaskService;
    
    @RestController
    @RequestMapping("test")
    public class TaskController {
        
    
    	@Autowired
    	private TaskService service;
    
    	@GetMapping("asyncNonBlocking")
    	public String asyncNonBlocking() {
        
    		// 异步执行任务
    		service.executeAsyncNonBlocking();
    		return "异步任务（非阻塞）已完成！";
    	}
    
    	@GetMapping("async")
    	public String async() {
        
    		// 异步执行任务
    		try {
        
    			service.executeAsync();
    		} catch (InterruptedException e) {
        
    			e.printStackTrace();
    		} catch (ExecutionException e) {
        
    			e.printStackTrace();
    		}
    		return "异步任务已完成！";
    	}
    
    	@GetMapping("sync")
    	public String sync() {
        
    		// 同步执行任务
    		service.executeSync();
    		return "同步任务已完成！";
    	}
    
    }

## 4. 执行结果 ##

### 4.1. 同步执行任务的时间 ###

执行同步任务的方法 `executeSync`，执行的结果和执行所需的时间如下：  
![在这里插入图片描述][b46f9b876dd44066b6ca6f615956fa87.png]

### 4.2. 异步执行任务的时间 ###

执行异步任务的方法 `executeAsync`，执行的结果和执行所需的时间如下：  
![在这里插入图片描述][e17bc4814aac4245bd82ab33e6525d6e.png]

### 4.3. 异步执行任务（非阻塞）的时间 ###

执行异步任务（非阻塞）的方法 `executeAsyncNonBlocking`，执行的结果和执行所需的时间如下：  
![在这里插入图片描述][7b54dccf071445258f91d9b8b8af7a33.png]  
主线程执行结束，接口就直接返回响应给用户了，任务在后台继续执行，直到所有任务全部执行完成。

### 4.4. 结论 ###

1.  异步任务，可以将几个子任务同时执行，然后在总任务中汇总。
2.  异步任务总的执行时间，就是多个子任务执行时间的最大值。
3.  非阻塞任务，接口会直接返回响应，任务仍在后台执行直至完成。

## 5. 示例项目（Gitee开源） ##

[异步任务示例项目（Gitee开源）][Gitee]

[b46f9b876dd44066b6ca6f615956fa87.png]: https://img-blog.csdnimg.cn/b46f9b876dd44066b6ca6f615956fa87.png
[e17bc4814aac4245bd82ab33e6525d6e.png]: https://img-blog.csdnimg.cn/e17bc4814aac4245bd82ab33e6525d6e.png
[7b54dccf071445258f91d9b8b8af7a33.png]: https://img-blog.csdnimg.cn/7b54dccf071445258f91d9b8b8af7a33.png
[Gitee]: https://gitee.com/songguanxun/blog-demo/tree/master/AsyncDemo