三步轻松学习Spring多线程，异步+回调+返回值！

最新推荐文章于 2024-05-16 11:57:54 发布

无敌路路帅气

最新推荐文章于 2024-05-16 11:57:54 发布

阅读量1.6k

点赞数 1

分类专栏： Spring-boot 文章标签：多线程 spring thread spring boot

本文链接：https://blog.csdn.net/m0_59562547/article/details/120214783

版权

Spring-boot 专栏收录该内容

21 篇文章 3 订阅

订阅专栏

大数据时代，面对海量数据与请求，我们需要使用多线程和并发编程来实现。传统多线程作业配置应用非常繁琐，今天就教大家三步轻松学习使用Spring多线程，实现异步作业+回调函数+收集返回值。

第一步：自定义多线程配置ThreadConfig

通过@EnableAsync注解开启异步多线程，通过AsyncConfigurer接口@Override重写getAsyncExecutor方法，就可以轻松使用Spring给我们提供的线程池ThreadPoolTaskExecutor。我们对线程池进行简单的配置，代码如下：

package com.example.demohelloworld.Thread;
import org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.AsyncConfigurer;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import java.util.concurrent.Executor;
import java.util.concurrent.ThreadPoolExecutor;
/**
 * 【配置类】直接实现AsyncConfigurer接口，重写getAsyncExecutor方法，获得一个ThreadPoolTaskExecutor异步线程池
 * @EnableAsync注解开启异步多线程
 */
@Configuration
@EnableAsync
public class ThreadConfig implements AsyncConfigurer {
    @Override
    public Executor getAsyncExecutor(){
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        //核心线程数
        executor.setCorePoolSize(5);
        //最大线程数
        executor.setMaxPoolSize(20);
        //等待(缓冲)队列
        executor.setQueueCapacity(50);
        //线程允许空闲时间
        executor.setKeepAliveSeconds(600);
        //设置拒绝策略：AbortPolicy直接抛出异常(默认)；CallerRunsPolicy用调用者所在的线程来执行任务；DiscardOldestPolicy丢弃阻塞队列中靠最前的任务，并执行当前任务；DiscardPolicy直接丢弃任务；
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        //等待所有任务结束后关闭线程池        
        executor.setWaitForTasksToCompleteOnShutdown(true);
        //线程池初始化
        executor.initialize();
        return executor;
    }
    @Override
    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler(){
        return AsyncConfigurer.super.getAsyncUncaughtExceptionHandler();
    }
}

第二步：创建多线程任务服务ThreadService

通过@Async定义一个多线程任务，本文我们定义两个带返回值的异步多线程任务，均设置任务开始输出、任务结束输出和任务模拟耗时。

通过Future<T>泛型接口，接收任务执行结果，并通过AsyncResult作为载体返回执行结果，代码如下：

package com.example.demohelloworld.Thread;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.AsyncResult;
import org.springframework.stereotype.Component;
import java.util.concurrent.Future;
/**
 * 【多线程服务类】使用@Async定义一个异步线程任务
 * Future泛型接口，用来接收任务执行结果，如果不要返回值只需要把方法改为void返回即可
 * 模拟两个异步线程任务
 */
@Component
public class ThreadService {
    //自定义日志输出
    Logger logger = LoggerFactory.getLogger(this.getClass());
    @Async//异步任务一
    public Future<String> asyncTask1(Integer i){
        //返回值
        String result1 = "";
        try {
            logger.info("任务1：进程"+i+"开始>>");
            Thread.sleep(2000);//任务一模拟耗时2秒
            logger.info("任务1：进程"+i+"结束");
            result1="任务1：进程"+i+"返回结果[]";
        }catch (InterruptedException ex){
            logger.info("任务1：进程"+i+"错误："+ex.getMessage());
        }
        //返回线程执行结果
        return new AsyncResult<String>(result1);
    }
    @Async//异步任务二
    public Future<String> asyncTask2(Integer i){
        String result2 = "";
        try {
            logger.info("任务2：进程"+i+"开始>>");
            Thread.sleep(1000);//任务二模拟耗时1秒
            logger.info("任务2：进程"+i+"结束");
            result2="任务2：进程"+i+"返回结果[]";
        }catch (InterruptedException ex){
            logger.info("任务2：进程"+i+"错误："+ex.getMessage());
        }
        return new AsyncResult<String>(result2);
    }
}

第三步：创建执行类调用多线程服务ThreadController

创建三个执行接口，模拟执行多线程服务，并通过future回调函数获取返回值。

①单任务使用线程池，并发数量小于等于核心线程数量，本文核心线程设置为5。

②单任务使用线程池，并发数量大于核心线程数量。

③多任务同时使用线程池，体验异步效果。

package com.example.demohelloworld.Thread;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
/**
 *【调用类】异步方法和调用类(执行类)不要放在同一个类中
 * 回调函数处理返回结果，一定要批量读取结果, 否则不能达到异步的效果
 */
@RestController
public class ThreadController {
    Logger logger = LoggerFactory.getLogger(this.getClass());
    @Autowired
    ThreadService threadService;
    @GetMapping("/thread1")
    //单任务使用线程池，并发数量小于等于核心线程数量
    public void thread1(){
        //设置返回值结果集
        List<Future<String>> futures= new ArrayList<>();
        for(int i=1;i<=5;i++){
            //执行任务1，回调函数获取任务1返回值
            Future<String> future1 = threadService.asyncTask1(i);
            futures.add(future1);
        }
        //回调函数批量读取返回结果,一定要批量读取结果, 否则不能达到异步的效果
        try {
            for(Future f:futures){
                //循环输出返回值
                logger.info((String) f.get());
            }
        }catch (ExecutionException | InterruptedException ex){
            logger.info("回调返回值发生错误："+ex.getMessage());
        }
    }
    //单任务使用线程池，并发数量大于核心线程数量
    @GetMapping("/thread2")
    public void thread2(){
        List<Future<String>> futures= new ArrayList<>();
        for(int i=1;i<=8;i++){
            //执行任务1，回调函数获取任务1返回值
            Future<String> future1 = threadService.asyncTask1(i);
            futures.add(future1);
        }
        //回调函数批量读取返回结果
        try {
            for(Future f:futures){
                logger.info((String) f.get());
            }
        }catch (ExecutionException | InterruptedException ex){
            logger.info("回调返回值发生错误："+ex.getMessage());
        }
    }
    //多任务同时使用线程池，体验异步效果
    @GetMapping("/thread3")
    public void thread3(){
        List<Future<String>> futures= new ArrayList<>();
        //任务一和任务二均执行同样并发任务
        for(int i=1;i<=5;i++){
            //执行线程1，回调函数获取线程1返回值
            Future<String> future1 = threadService.asyncTask1(i);
            futures.add(future1);
            //执行线程2，回调函数获取线程2返回值
            Future<String> future2 =threadService.asyncTask2(i);
            futures.add(future2);
        }
        try {
            for(Future f:futures){
                logger.info((String) f.get());
            }
        }catch (ExecutionException | InterruptedException ex){
            logger.info("回调返回值发生错误："+ex.getMessage());
        }
    }
}

搭建完毕开始测试

启动项目，打开浏览器输入http://localhost:8080/thread1，执行接口1，结果如下：

ThreadService    : 任务1：进程3开始>>
ThreadService    : 任务1：进程2开始>>
ThreadService    : 任务1：进程1开始>>
ThreadService    : 任务1：进程4开始>>
ThreadService    : 任务1：进程5开始>>
ThreadService    : 任务1：进程1结束
ThreadService    : 任务1：进程4结束
ThreadService    : 任务1：进程3结束
ThreadService    : 任务1：进程2结束
ThreadService    : 任务1：进程5结束
ThreadController : 任务1：进程1返回结果[]
ThreadController : 任务1：进程2返回结果[]
ThreadController : 任务1：进程3返回结果[]
ThreadController : 任务1：进程4返回结果[]
ThreadController : 任务1：进程5返回结果[]

单任务使用线程池，并发数量5小于等于核心线程数量5时，可见进程全部异步(无序)启动并执行(开始到结束模拟耗时2秒)，在全部进程执行完毕后，输出返回结果。

打开浏览器输入http://localhost:8080/thread2，执行接口2，结果如下：

ThreadService    : 任务1：进程5开始>>
ThreadService    : 任务1：进程3开始>>
ThreadService    : 任务1：进程4开始>>
ThreadService    : 任务1：进程2开始>>
ThreadService    : 任务1：进程1开始>>
ThreadService    : 任务1：进程5结束
ThreadService    : 任务1：进程1结束
ThreadService    : 任务1：进程2结束
ThreadService    : 任务1：进程4结束
ThreadService    : 任务1：进程3结束
ThreadController : 任务1：进程1返回结果[]
ThreadService    : 任务1：进程8开始>>
ThreadService    : 任务1：进程7开始>>
ThreadService    : 任务1：进程6开始>>
ThreadController : 任务1：进程2返回结果[]
ThreadController : 任务1：进程3返回结果[]
ThreadController : 任务1：进程4返回结果[]
ThreadController : 任务1：进程5返回结果[]
ThreadService    : 任务1：进程6结束
ThreadService    : 任务1：进程7结束
ThreadService    : 任务1：进程8结束
ThreadController : 任务1：进程6返回结果[]
ThreadController : 任务1：进程7返回结果[]
ThreadController : 任务1：进程8返回结果[]

单任务使用线程池，并发数量8大于核心线程数量5时，可见5个进程异步(无序)启动并执行，待5个进程执行完毕后剩余3个进程开始启动，并逐步输出前5个进程的返回结果，待剩余3个进程执行完毕后，输出剩余结果。

打开浏览器输入http://localhost:8080/thread3，执行接口3，结果如下：

ThreadService    : 任务2：进程1开始>>
ThreadService    : 任务2：进程2开始>>
ThreadService    : 任务1：进程1开始>>
ThreadService    : 任务1：进程2开始>>
ThreadService    : 任务1：进程3开始>>
ThreadService    : 任务2：进程2结束
ThreadService    : 任务2：进程1结束
ThreadService    : 任务2：进程3开始>>
ThreadService    : 任务1：进程4开始>>
ThreadService    : 任务1：进程1结束
ThreadService    : 任务1：进程3结束
ThreadService    : 任务1：进程2结束
ThreadController : 任务1：进程1返回结果[]
ThreadService    : 任务1：进程5开始>>
ThreadService    : 任务2：进程4开始>>
ThreadService    : 任务2：进程5开始>>
ThreadController : 任务2：进程1返回结果[]
ThreadController : 任务1：进程2返回结果[]
ThreadController : 任务2：进程2返回结果[]
ThreadController : 任务1：进程3返回结果[]
ThreadService    : 任务2：进程3结束
ThreadController : 任务2：进程3返回结果[]
ThreadService    : 任务2：进程4结束
ThreadService    : 任务2：进程5结束
ThreadService    : 任务1：进程4结束
ThreadController : 任务1：进程4返回结果[]
ThreadController : 任务2：进程4返回结果[]
ThreadService    : 任务1：进程5结束
ThreadController : 任务1：进程5返回结果[]
ThreadController : 任务2：进程5返回结果[]

多任务同时使用线程池，任务一(包含5个进程，模拟耗时2秒)，任务二(也包含5个进程，模拟耗时1秒)，两个任务同时使用5个核心线程池。包含任务1和任务2的5个进程异步启动并执行，任务2的两个进程先执行完毕，后又加入新的异步进程开始执行。待第一轮5个进程陆续执行完毕后，开始逐步输出返回结果，整个过程可以充分体验异步多线程执行的效果。

无敌路路帅气

关注

1
点赞
踩
6

收藏

觉得还不错? 一键收藏
0
评论
三步轻松学习Spring多线程，异步+回调+返回值！

大数据时代，面对海量数据与请求，我们需要使用多线程和并发编程来实现。传统多线程作业配置应用非常繁琐，今天就教大家三步轻松学习使用Spring多线程，实现异步作业+回调函数+收集返回值。第一步：自定义多线程配置ThreadConfig通过@EnableAsync注解开启异步多线程，通过AsyncConfigurer接口@Override重写getAsyncExecutor方法，就可以轻松使用Spring给我们提供的线程池ThreadPoolTaskExecutor。我们对线程池进行简单的配置，代码如下
复制链接

扫一扫