1. SpringBoot多线程异步任务
1.1. 需求
在 SpringBoot 项目中，一个任务比较复杂，执行时间比较长，需要采用 多线程异步 的方式执行，从而缩短任务执行时间。
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，执行的结果和执行所需的时间如下：
4.2. 异步执行任务的时间
执行异步任务的方法 executeAsync，执行的结果和执行所需的时间如下：
4.3. 异步执行任务（非阻塞）的时间
执行异步任务（非阻塞）的方法 executeAsyncNonBlocking，执行的结果和执行所需的时间如下：
主线程执行结束，接口就直接返回响应给用户了，任务在后台继续执行，直到所有任务全部执行完成。文章来源：https://www.toymoban.com/news/detail-498317.html
4.4. 结论
- 异步任务，可以将几个子任务同时执行，然后在总任务中汇总。
- 异步任务总的执行时间，就是多个子任务执行时间的最大值。
- 非阻塞任务，接口会直接返回响应，任务仍在后台执行直至完成。
5. 示例项目（Gitee开源）
异步任务示例项目（Gitee开源）文章来源地址https://www.toymoban.com/news/detail-498317.html
到了这里，关于SpringBoot多线程异步任务：ThreadPoolTaskExecutor + CompletableFuture的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
