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

SpringBoot多线程异步任务

需求

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

多线程异步

  1. 将任务拆分成多个独立的子任务,每个子任务在独立子线程中执行;
  2. 当所有子任务的子线程全部执行完成后,将几个子任务汇总,得到总任务的执行结果。
  • 非阻塞:在汇总子任务时,不会阻塞主线程,也就是说汇总任务,也是在子线程执行的。开启了执行子任务和执行汇总任务的线程后,主线程就继续向下执行了。
  • 阻塞:在汇总子任务时,阻塞主线程,等待所有子任务执行完成并且汇总后,程序才继续向下执行。

解决方案

ThreadPoolTaskExecutor + CompletableFuture

ThreadPoolTaskExecutor:是Spring框架提供的。
CompletableFuture:是 java 提供的(Java8 及以上)。

代码实现

异步任务和同步任务

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);
		}
	}

}

执行任务(异步任务和同步任务)

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 "同步任务已完成!";
	}

}

执行结果

同步执行任务的时间

执行同步任务的方法 executeSync,执行的结果和执行所需的时间如下:
SpringBoot多线程异步任务:ThreadPoolTaskExecutor + CompletableFuture_第1张图片

异步执行任务的时间

执行异步任务的方法 executeAsync,执行的结果和执行所需的时间如下:
SpringBoot多线程异步任务:ThreadPoolTaskExecutor + CompletableFuture_第2张图片

异步执行任务(非阻塞)的时间

执行异步任务(非阻塞)的方法 executeAsyncNonBlocking,执行的结果和执行所需的时间如下:
SpringBoot多线程异步任务:ThreadPoolTaskExecutor + CompletableFuture_第3张图片
主线程执行结束,接口就直接返回响应给用户了,任务在后台继续执行,直到所有任务全部执行完成。

结论

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

示例项目

异步任务示例项目(Gitee)

你可能感兴趣的:(Spring,spring,boot,java,spring)