springboot项目如何支持（Future、ThreadPoolTaskExecutor、CountDownLatch、Callable、Runnable）对异步任务的支持和处理

最新推荐文章于 2024-04-11 17:47:41 发布

薇薇

最新推荐文章于 2024-04-11 17:47:41 发布

阅读量1.7k

点赞数

分类专栏： spring-cloud

本文链接：https://blog.csdn.net/qqzhengwei/article/details/117514799

版权

spring-cloud 专栏收录该内容

11 篇文章 1 订阅

订阅专栏

参考：

https://juejin.cn/post/6844903774985650183

https://blog.csdn.net/weixin_43491745/article/details/107665756 学习借鉴和快捷键记录上

创建线程的方式

通过继承Thread类

public class MyThread extends Thread {

    @Override
    public void run() {
        System.out.println("线程已执行。。。");
    }
}

实现接口

public class MyThread2 implements Runnable {

    @Override
    public void run() {
        System.out.println("基于实现Runnable接口的多线程");
    }
}

Callable的使用

Future的使用

Future就是对于具体的Runnable或者Callable任务的执行结果进行取消、查询是否完成、获取结果。必要时可以通过get方法获取执行结果，该方法会阻塞直到任务返回结果。

FutureTask为其最终具体的实现类；

Future提供了三种功能：

判断任务是否完成；
能够中断任务；
能够获取任务执行结果。

ThreadPoolTaskExecutor 线程池Task

也就是说通过线程池的方式不仅解决了针对Runnable多线程的实现类，无法获取结果的问题（广义上），也可以使用Callable的实现类获取执行结果的；

execute执行一个线程，需要返回值的
//不需要返回值的
@Override
public void execute(Runnable task) {
	Executor executor = getThreadPoolExecutor();
	try {
		executor.execute(task);
	}
	catch (RejectedExecutionException ex) {
		throw new TaskRejectedException("Executor [" + executor + "] did not accept task: " + task, ex);
	}
}

//需要返回值的
@Override
public Future<?> submit(Runnable task) {
	ExecutorService executor = getThreadPoolExecutor();
	try {
		return executor.submit(task);
	}
	catch (RejectedExecutionException ex) {
		throw new TaskRejectedException("Executor [" + executor + "] did not accept task: " + task, ex);
	}
}

//Callable带返回值的
@Override
public <T> Future<T> submit(Callable<T> task) {
	ExecutorService executor = getThreadPoolExecutor();
	try {
		return executor.submit(task);
	}
	catch (RejectedExecutionException ex) {
		throw new TaskRejectedException("Executor [" + executor + "] did not accept task: " + task, ex);
	}
}

示例（1）异步任务，同步阻塞

import cn.hutool.core.date.DateUtil;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class TestThreadPool {

    public static void main(String[] args) throws InterruptedException {
        ThreadPoolTaskExecutor threadPoolTaskExecutor = new ThreadPoolTaskExecutor();
        threadPoolTaskExecutor.setThreadNamePrefix("xxxx-");
        //配置核心线程数
        threadPoolTaskExecutor.setCorePoolSize(5);
        //配置最大线程数
        threadPoolTaskExecutor.setMaxPoolSize(10);
        //配置队列大小
        threadPoolTaskExecutor.setQueueCapacity(100);
        threadPoolTaskExecutor.setKeepAliveSeconds(300);
        threadPoolTaskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.DiscardPolicy() {
            @Override
            public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
                System.out.println("丢弃");
            }
        });
        threadPoolTaskExecutor.initialize();
        int taskNum = 10;
        CountDownLatch latch = new CountDownLatch(taskNum);
        for (int i = 0; i < taskNum; i++) {
            final int taskId = i;
            threadPoolTaskExecutor.execute(() -> {
                try {
                    System.out.printf("线程号: %s, 多线程名称: %s,当前子任务需要执行 %s 秒, start at %s\n", taskId, Thread.currentThread().getName(),
                            taskId * taskId, DateUtil.now());
                    TimeUnit.SECONDS.sleep(taskId * taskId);
                    System.out.printf("task: %s, thread: %s,当前子任务执行 %s 秒【任务处理完毕】, end at %s\n", taskId, Thread.currentThread().getName()
                            ,taskId * taskId, DateUtil.now());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    latch.countDown();
                }
            });
        }
        System.out.println("主程序执行。。。马上等待子线程执行结束后继续");
        System.out.println("主线程等待中....");
        latch.await();
        System.out.println("子线程任务执行完毕");
        System.out.println("主程序继续执行。。。。");
        threadPoolTaskExecutor.shutdown();
    }
}

创建一个ThreadPoolTaskExecutor 线程池，然后所有需要执行的线程都丢给ThreadPoolTaskExecutor线程池进行运行；

本例主要模拟，通过线程池的execute方法，来执行无返回值的异步任务。如果想实现同步效果，我们就使用了CountDownLatch；

有多少个需要主线程等待的子线程执行，就将CountDownLatch的初始化数量设置多相应的值；

主要实现步骤

CountDownLatch countDownLatch = new CountDownLatch(3);


countDownLatch.await();//在主线程中加入此代码，让主线程阻塞，等待子线程完毕后在继续执行主线程的其他代码；
//什么时候开始执行主线程的代码呢？

在子线程执行逻辑代码中使用
latch.countDown();  这个就是把初始化的3一个一个减；
当假如说有3个子线程在执行，子线程没执行完毕一个，latch.countDown();就将3进行-1；2-1；1-1；直到
为0的时候表示所有的子线程都已经全部执行完毕；然后主线程开始执行

这个使用了阻塞的原理

控制台输出

14:21:11.840 [main] INFO org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor - Initializing ExecutorService
主程序执行。。。马上等待子线程执行结束后继续
主线程等待中....
线程号: 1, 多线程名称: xxxx-2,当前子任务需要执行 1 秒, start at 2021-06-03 14:21:11
线程号: 0, 多线程名称: xxxx-1,当前子任务需要执行 0 秒, start at 2021-06-03 14:21:11
task: 0, thread: xxxx-1,当前子任务执行 0 秒【任务处理完毕】, end at 2021-06-03 14:21:12
线程号: 5, 多线程名称: xxxx-1,当前子任务需要执行 25 秒, start at 2021-06-03 14:21:12
线程号: 3, 多线程名称: xxxx-4,当前子任务需要执行 9 秒, start at 2021-06-03 14:21:11
线程号: 2, 多线程名称: xxxx-3,当前子任务需要执行 4 秒, start at 2021-06-03 14:21:11
线程号: 4, 多线程名称: xxxx-5,当前子任务需要执行 16 秒, start at 2021-06-03 14:21:11
task: 1, thread: xxxx-2,当前子任务执行 1 秒【任务处理完毕】, end at 2021-06-03 14:21:13
线程号: 6, 多线程名称: xxxx-2,当前子任务需要执行 36 秒, start at 2021-06-03 14:21:13
task: 2, thread: xxxx-3,当前子任务执行 4 秒【任务处理完毕】, end at 2021-06-03 14:21:16
线程号: 7, 多线程名称: xxxx-3,当前子任务需要执行 49 秒, start at 2021-06-03 14:21:16
task: 3, thread: xxxx-4,当前子任务执行 9 秒【任务处理完毕】, end at 2021-06-03 14:21:21
线程号: 8, 多线程名称: xxxx-4,当前子任务需要执行 64 秒, start at 2021-06-03 14:21:21
task: 4, thread: xxxx-5,当前子任务执行 16 秒【任务处理完毕】, end at 2021-06-03 14:21:28
线程号: 9, 多线程名称: xxxx-5,当前子任务需要执行 81 秒, start at 2021-06-03 14:21:28
task: 5, thread: xxxx-1,当前子任务执行 25 秒【任务处理完毕】, end at 2021-06-03 14:21:37
task: 6, thread: xxxx-2,当前子任务执行 36 秒【任务处理完毕】, end at 2021-06-03 14:21:49
task: 7, thread: xxxx-3,当前子任务执行 49 秒【任务处理完毕】, end at 2021-06-03 14:22:05
task: 8, thread: xxxx-4,当前子任务执行 64 秒【任务处理完毕】, end at 2021-06-03 14:22:25
task: 9, thread: xxxx-5,当前子任务执行 81 秒【任务处理完毕】, end at 2021-06-03 14:22:49
子线程任务执行完毕
主程序继续执行。。。。

实例（2）Future 无返回值的异步任务，获取结果

import cn.hutool.core.date.DateUtil;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class TestThreadPool2 {

    public static void main(String[] args) throws InterruptedException, ExecutionException {

        ThreadPoolTaskExecutor threadPoolTaskExecutor = new ThreadPoolTaskExecutor();
        threadPoolTaskExecutor.setThreadNamePrefix("xxxx-");
        //配置核心线程数
        threadPoolTaskExecutor.setCorePoolSize(5);
        //配置最大线程数
        threadPoolTaskExecutor.setMaxPoolSize(10);
        //配置队列大小
        threadPoolTaskExecutor.setQueueCapacity(100);
        threadPoolTaskExecutor.setKeepAliveSeconds(300);
        threadPoolTaskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.DiscardPolicy() {
            @Override
            public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
                System.out.println("丢弃");
            }
        });
        threadPoolTaskExecutor.initialize();

        int taskNum = 10;
        List<Future> taskFutureList = new ArrayList<>();
        for (int i = 0; i < taskNum; i++) {
            final int taskId = i;
            //public Future<?> submit(Runnable task) 调用的threadPoolTaskExecutor的方法；没有返回值的
            Future future = threadPoolTaskExecutor.submit(() -> {
                try {
                    System.out.printf("线程号: %s, 多线程名称: %s,当前子任务需要执行 %s 秒, start at %s\n", taskId, Thread.currentThread().getName(),
                            taskId * taskId, DateUtil.now());
                    TimeUnit.SECONDS.sleep(taskId * taskId);
                    System.out.printf("task: %s, thread: %s,当前子任务执行 %s 秒【任务处理完毕】, end at %s\n", taskId, Thread.currentThread().getName()
                            ,taskId * taskId, DateUtil.now());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
            taskFutureList.add(future);
        }

        System.out.println("主程序执行。。。马上等待子线程执行结束后继续");
        System.out.println("主线程等待中....");
        for (Future future : taskFutureList) {
            future.get();//同步阻塞，等待子线程执行完毕
        }
        System.out.println("子线程任务执行完毕");
        System.out.println("主程序继续执行。。。。");
        threadPoolTaskExecutor.shutdown();
    }
}

控制台输出

主程序执行。。。马上等待子线程执行结束后继续
主线程等待中....
线程号: 4, 多线程名称: xxxx-5,当前子任务需要执行 16 秒, start at 2021-06-03 14:14:12
线程号: 3, 多线程名称: xxxx-4,当前子任务需要执行 9 秒, start at 2021-06-03 14:14:12
线程号: 1, 多线程名称: xxxx-2,当前子任务需要执行 1 秒, start at 2021-06-03 14:14:12
线程号: 2, 多线程名称: xxxx-3,当前子任务需要执行 4 秒, start at 2021-06-03 14:14:12
线程号: 0, 多线程名称: xxxx-1,当前子任务需要执行 0 秒, start at 2021-06-03 14:14:12
task: 0, thread: xxxx-1,当前子任务执行 0 秒【任务处理完毕】, end at 2021-06-03 14:14:12
线程号: 5, 多线程名称: xxxx-1,当前子任务需要执行 25 秒, start at 2021-06-03 14:14:12
task: 1, thread: xxxx-2,当前子任务执行 1 秒【任务处理完毕】, end at 2021-06-03 14:14:13
线程号: 6, 多线程名称: xxxx-2,当前子任务需要执行 36 秒, start at 2021-06-03 14:14:13
task: 2, thread: xxxx-3,当前子任务执行 4 秒【任务处理完毕】, end at 2021-06-03 14:14:16
线程号: 7, 多线程名称: xxxx-3,当前子任务需要执行 49 秒, start at 2021-06-03 14:14:16
task: 3, thread: xxxx-4,当前子任务执行 9 秒【任务处理完毕】, end at 2021-06-03 14:14:21
线程号: 8, 多线程名称: xxxx-4,当前子任务需要执行 64 秒, start at 2021-06-03 14:14:21
task: 4, thread: xxxx-5,当前子任务执行 16 秒【任务处理完毕】, end at 2021-06-03 14:14:28
线程号: 9, 多线程名称: xxxx-5,当前子任务需要执行 81 秒, start at 2021-06-03 14:14:28
task: 5, thread: xxxx-1,当前子任务执行 25 秒【任务处理完毕】, end at 2021-06-03 14:14:37
task: 6, thread: xxxx-2,当前子任务执行 36 秒【任务处理完毕】, end at 2021-06-03 14:14:49
task: 7, thread: xxxx-3,当前子任务执行 49 秒【任务处理完毕】, end at 2021-06-03 14:15:05
task: 8, thread: xxxx-4,当前子任务执行 64 秒【任务处理完毕】, end at 2021-06-03 14:15:25
task: 9, thread: xxxx-5,当前子任务执行 81 秒【任务处理完毕】, end at 2021-06-03 14:15:49
子线程任务执行完毕
主程序继续执行。。。。

//通过控制台输出分析；
1、在主线程遇到Future.get()的时候，这个也会造成主程序阻塞；跟上面的的CountDownLatch一个效果

示例3 Future 有返回值的异步任务，获取结果

段1

import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadPoolExecutor;

public class TestThreadPool3 {

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ThreadPoolTaskExecutor threadPoolTaskExecutor = new ThreadPoolTaskExecutor();
        threadPoolTaskExecutor.setThreadNamePrefix("xxxx-");
        //配置核心线程数
        threadPoolTaskExecutor.setCorePoolSize(5);
        //配置最大线程数
        threadPoolTaskExecutor.setMaxPoolSize(10);
        //配置队列大小
        threadPoolTaskExecutor.setQueueCapacity(100);
        threadPoolTaskExecutor.setKeepAliveSeconds(300);
        threadPoolTaskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.DiscardPolicy() {
            @Override
            public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
                System.out.println("丢弃");
            }
        });
        threadPoolTaskExecutor.initialize();

        int taskNum = 10;
        DoService doService = new DoService();
        List<Future> taskFutureList = doService.getResult(threadPoolTaskExecutor,taskNum);


        System.out.println("主程序执行。。。马上等待子线程执行结束后继续");
        System.out.println("主线程等待中....");
        for (Future future : taskFutureList) {
            //这里模拟就返回了一个int 实例工作中可能更为复杂，返回复杂的对象等等
            System.out.println("【子线程】结果:" + future.get());//同步阻塞，等待子线程执行完毕
        }
        System.out.println("子线程任务执行完毕");
        System.out.println("主程序继续执行。。。。");
        threadPoolTaskExecutor.shutdown();
    }


}

段2

import cn.hutool.core.date.DateUtil;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;

/**
 * Created by user on 2021/6/3.
 */
public class DoService {

    public List<Future> getResult(ThreadPoolTaskExecutor threadPoolTaskExecutor, int taskNum) {
        List<Future> taskFutureList = new ArrayList<>();
        for (int i = 0; i < taskNum; i++) {
            int taskId = i;
            //public <T> Future<T> submit(Callable<T> task) { 调用的threadPoolTaskExecutor的方法；包含返回值的
            Future<Integer> future = threadPoolTaskExecutor.submit(() -> getResult(taskId));
            taskFutureList.add(future);
        }
        return taskFutureList;
    }

    public Integer getResult(int taskId) {
        try {
            System.out.printf("线程号: %s, 多线程名称: %s,当前子任务需要执行 %s 秒, start at %s\n", taskId, Thread.currentThread().getName(),
                    taskId * taskId, DateUtil.now());
            TimeUnit.SECONDS.sleep(taskId * taskId);
            System.out.printf("task: %s, thread: %s,当前子任务执行 %s 秒【任务处理完毕】, end at %s\n", taskId, Thread.currentThread().getName()
                    , taskId * taskId, DateUtil.now());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return taskId;
    }
}

这里在 Future<Integer> future = threadPoolTaskExecutor.submit(() -> getResult(taskId));提交的时候，由于需要返回值，所以这里通过lambda的方式声明了一个方法级别的声明；也就是返回值恰好就是Callable的实现；【为什么这样要去看lambda写法】

控制台输出

主程序执行。。。马上等待子线程执行结束后继续
主线程等待中....
线程号: 1, 多线程名称: xxxx-2,当前子任务需要执行 1 秒, start at 2021-06-03 14:38:09
线程号: 2, 多线程名称: xxxx-3,当前子任务需要执行 4 秒, start at 2021-06-03 14:38:09
线程号: 4, 多线程名称: xxxx-5,当前子任务需要执行 16 秒, start at 2021-06-03 14:38:09
线程号: 0, 多线程名称: xxxx-1,当前子任务需要执行 0 秒, start at 2021-06-03 14:38:09
线程号: 3, 多线程名称: xxxx-4,当前子任务需要执行 9 秒, start at 2021-06-03 14:38:09
task: 0, thread: xxxx-1,当前子任务执行 0 秒【任务处理完毕】, end at 2021-06-03 14:38:09
线程号: 5, 多线程名称: xxxx-1,当前子任务需要执行 25 秒, start at 2021-06-03 14:38:09
【子线程】结果:0
task: 1, thread: xxxx-2,当前子任务执行 1 秒【任务处理完毕】, end at 2021-06-03 14:38:10
【子线程】结果:1
线程号: 6, 多线程名称: xxxx-2,当前子任务需要执行 36 秒, start at 2021-06-03 14:38:10
task: 2, thread: xxxx-3,当前子任务执行 4 秒【任务处理完毕】, end at 2021-06-03 14:38:13
【子线程】结果:2
线程号: 7, 多线程名称: xxxx-3,当前子任务需要执行 49 秒, start at 2021-06-03 14:38:13
task: 3, thread: xxxx-4,当前子任务执行 9 秒【任务处理完毕】, end at 2021-06-03 14:38:18
【子线程】结果:3
线程号: 8, 多线程名称: xxxx-4,当前子任务需要执行 64 秒, start at 2021-06-03 14:38:18
task: 4, thread: xxxx-5,当前子任务执行 16 秒【任务处理完毕】, end at 2021-06-03 14:38:25
【子线程】结果:4
线程号: 9, 多线程名称: xxxx-5,当前子任务需要执行 81 秒, start at 2021-06-03 14:38:25
task: 5, thread: xxxx-1,当前子任务执行 25 秒【任务处理完毕】, end at 2021-06-03 14:38:34
【子线程】结果:5
task: 6, thread: xxxx-2,当前子任务执行 36 秒【任务处理完毕】, end at 2021-06-03 14:38:47
【子线程】结果:6
task: 7, thread: xxxx-3,当前子任务执行 49 秒【任务处理完毕】, end at 2021-06-03 14:39:02
【子线程】结果:7
task: 8, thread: xxxx-4,当前子任务执行 64 秒【任务处理完毕】, end at 2021-06-03 14:39:22
【子线程】结果:8
task: 9, thread: xxxx-5,当前子任务执行 81 秒【任务处理完毕】, end at 2021-06-03 14:39:46
【子线程】结果:9
子线程任务执行完毕
主程序继续执行。。。。

小小总结：

要实现异步任务，首先它的原理不用多想，都是基于多线程的；为什么需要线程池，为了避免对资源的浪费和对核心线程的控制提高程序的执行效率，所以采用线程池；

ThreadPoolTaskExecutor 线程池（创建）
Future用于获取

参考：https://juejin.cn/post/6844904033673560077

CountDownLatch 这个不是必须，如果补使用Future时，这个要实现多线程运行同步获取结果，这个是对Future的补充；
Callable和Runnable具体实现主要提交给ThreadPoolTaskExecutor的submit和execute的执行参数；

ThreadPoolTaskExecutor核心方法

ThreadPoolTaskExecutor类的几个核心方法
三种方法
一、execute接收一个Runnable的实现类，然后没有返回值；
要想实现同步获取结果需要使用CountDownLatch配合使用；【学习示例中有的】
二、submit接收一个Runnable的实现类，然后返回Future;
这个就是多线程需要同步获取异步任务返回结果，最终通过Future.get()获取结果；
当主线程Future.get()的时候，这样会导致主线程阻塞，然后等待异步子线程执行完毕并获取结果；
三、submit接收一个Callable的实现类，然后返回Future;
其中Callable这个接口（函数式接口）
@FunctionalInterface
public interface Callable<V> {
    /**
     * Computes a result, or throws an exception if unable to do so.
     *
     * @return computed result
     * @throws Exception if unable to compute a result
     */
    V call() throws Exception;
}
这个就是多线程需要同步获取异步任务返回结果，最终通过Future.get()获取结果；
当主线程Future.get()的时候，这样会导致主线程阻塞，然后等待异步子线程执行完毕并获取结果；



@Override
public void execute(Runnable task) {
	Executor executor = getThreadPoolExecutor();
	try {
		executor.execute(task);
	}
	catch (RejectedExecutionException ex) {
		throw new TaskRejectedException("Executor [" + executor + "] did not accept task: " + task, ex);
	}
}

@Override
public Future<?> submit(Runnable task) {
	ExecutorService executor = getThreadPoolExecutor();
	try {
		return executor.submit(task);
	}
	catch (RejectedExecutionException ex) {
		throw new TaskRejectedException("Executor [" + executor + "] did not accept task: " + task, ex);
	}
}

@Override
public <T> Future<T> submit(Callable<T> task) {
	ExecutorService executor = getThreadPoolExecutor();
	try {
		return executor.submit(task);
	}
	catch (RejectedExecutionException ex) {
		throw new TaskRejectedException("Executor [" + executor + "] did not accept task: " + task, ex);
	}
}

CountDownLatch的ThreadPoolTaskExecutor.execute()同步获取结果

线程池ThreadPoolTaskExecutor（springboot自动创建原理）

在springboot项目开发，采用了springboot，不用你配，自动就配置好了。TaskExecutionAutoConfiguration在这个自动配置类中。

@ConditionalOnClass({ThreadPoolTaskExecutor.class})
@Configuration(
    proxyBeanMethods = false
)
@EnableConfigurationProperties({TaskExecutionProperties.class})
public class TaskExecutionAutoConfiguration {
    public static final String APPLICATION_TASK_EXECUTOR_BEAN_NAME = "applicationTaskExecutor";

    public TaskExecutionAutoConfiguration() {
    }

    @Bean
    @ConditionalOnMissingBean
    public TaskExecutorBuilder taskExecutorBuilder(TaskExecutionProperties properties, ObjectProvider<TaskExecutorCustomizer> taskExecutorCustomizers, ObjectProvider<TaskDecorator> taskDecorator) {
        Pool pool = properties.getPool();
        TaskExecutorBuilder builder = new TaskExecutorBuilder();
        builder = builder.queueCapacity(pool.getQueueCapacity());
        builder = builder.corePoolSize(pool.getCoreSize());
        builder = builder.maxPoolSize(pool.getMaxSize());
        builder = builder.allowCoreThreadTimeOut(pool.isAllowCoreThreadTimeout());
        builder = builder.keepAlive(pool.getKeepAlive());
        Shutdown shutdown = properties.getShutdown();
        builder = builder.awaitTermination(shutdown.isAwaitTermination());
        builder = builder.awaitTerminationPeriod(shutdown.getAwaitTerminationPeriod());
        builder = builder.threadNamePrefix(properties.getThreadNamePrefix());
        Stream var10001 = taskExecutorCustomizers.orderedStream();
        var10001.getClass();
        builder = builder.customizers(var10001::iterator);
        builder = builder.taskDecorator((TaskDecorator)taskDecorator.getIfUnique());
        return builder;
    }

    @Lazy
    @Bean(
        name = {"applicationTaskExecutor", "taskExecutor"}
    )
    @ConditionalOnMissingBean({Executor.class})
    public ThreadPoolTaskExecutor applicationTaskExecutor(TaskExecutorBuilder builder) {
        return builder.build();
    }
}

也就是系统自动后就创建了一个ThreadPoolTaskExecutor线程池，名字叫做applicationTaskExecutor或者taskExecutor

如果不想用默认的自己配置一个也是可以的

@Configuration
//这个当你需要使用异步任务的时候要加；异步任务最终也是由ThreadPoolTaskExecutor线程池来执行的
//@EnableAsync// 开启异步注解功能
public class ExecutorConfig {

    /**
     * 线程池的配置
     *
     * @Param []
     * @Return java.util.concurrent.Executor
     */
    @Bean
    public ThreadPoolTaskExecutor threadPoolExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        //配置核心线程数
        executor.setCorePoolSize(5);
        //配置最大线程数
        executor.setMaxPoolSize(10);
        //配置队列大小
        executor.setQueueCapacity(100);

        //配置线程池中的线程的名称前缀
        executor.setThreadNamePrefix("threadPool-");
        // rejection-policy：当pool已经达到max size的时候，并且队列已经满了，如何处理新任务
        // DiscardPolicy: 直接丢弃
        // CallerRunsPolicy：不在新线程中执行任务，而是有调用者所在的线程来执行
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        //执行初始化
        executor.initialize();
        // 等待所有任务结束后再关闭线程池
        executor.setWaitForTasksToCompleteOnShutdown(true);
        return executor;
    }
}

薇薇

关注

0
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
springboot项目如何支持（Future、ThreadPoolTaskExecutor、CountDownLatch、Callable、Runnable）对异步任务的支持和处理

参考：https://juejin.cn/post/6844903774985650183创建线程的方式通过继承Thread类public class MyThread extends Thread { @Override public void run() { System.out.println("线程已执行。。。"); }}实现接口public class MyThread2 implements Runnable { ...
复制链接

扫一扫