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

最新推荐文章于 2021-10-10 16:35:58 发布
最新推荐文章于 2021-10-10 16:35:58 发布
阅读量1.7k 收藏 5
点赞数
分类专栏： spring-cloud
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qqzhengwei/article/details/117514799
版权

 

参考：

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提供了三种功能：

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

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

 

 

 

 

 

 

薇薇
关注
专栏目录
SpringBoot实践（二十二）：线程基础
叶子叶来
07-11 656
当我们完成业务逻辑开发，把jar包发布到环境中启动，就是在该主机上拉起了1个进程，该进程会进行系统调用监听端口请求，返回计算结果，同一代码段（或者方法），比如用户登录方法在同时刻可以有多个请求过来，每个请求就是1个处理线程，线程是CPU的最小处理单元，可以把进程比作工厂，线程是流水线，工厂包含原材料、启动/关闭多个流水线、输出产物。......
Java多线程实战：FutureTask与CountDownLatch的完美结合
青云桑的小窝
03-18 9515
前提概要 在知乎上看到一道Java多线程的笔试题，心想我多线程只会Thread和Runable，在写WebFluxTest用过一次CountDownLatch，除此之外还没怎么去看cocurrent包下的类，所以就想试试。 题目 知乎传送门：某大型电商Java面试题：一主多从多线程协作 客户请求下单服务（OrderService），服务端会验证用户的身份（RemotePassportS...
在Springboot中使用线程池ThreadPoolTaskExecutor
愿世界和平
10-22 7979
package com.markor.template.config; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.scheduling.concurrent.T...
springboot配合FutureTask/Callable实现并行处理
weixin_43262188的博客
10-29 5835
一、简介 很多同学在学多线程的时候不知道它后来能用在哪儿，这里我提供一个使用多线程的小思路。 现有一个微服务场景，用户想查看某个作者和该作者写的文章。那么他需要从用户服务和文章服务分别去调然后等待结果一起返回。假如用户服务需要2秒返回结果，文章服务需要3秒返回结果，加起来就是5秒，如果业务在复杂一点可能还会调别的服务，例如订单服务、商品服务。。。那么如此我们的调用时间是累加的。系统的等待时间随着业...
Java多线程之ThreadPoolExecutor和Future结合使用
南北雪树的专栏
12-19 2473
List> returnFuture = new ArrayList<>(); ThreadFactory namedThreadFactory = new ThreadFactoryBuilder().setNameFormat("openAccount-pool-%d").build(); ExecutorService pool = new ThreadPoolExecutor(2,
springboot使用线程池ThreadPoolTaskExecutor如何知道全部执行完?
热门推荐
IT打工匠
05-08 4万+
1.使用线程池ThreadPoolTaskExecutor,执行多线程任务时,通过CountDownLatch CountDownLatch是一个同步的辅助类，它可以允许一个或多个线程等待，直到一组在其它线程中的操作执行完成。 一个CountDownLatch会通过一个给定的count数来被初始化。其中await()方法会一直阻塞，直到当前的count被减到0，而这个过程是通过调用coun...
SpringBoot2.x整合线程池（ThreadPoolTaskExecutor）多个异步任务执行结果获取、异常处理
神奇的酱油的博客
12-14 2215
参考了这篇文章：SpringBoot2.x整合线程池（ThreadPoolTaskExecutor） https://www.jianshu.com/p/3d875dd9d5db 异步执行结果集处理及异常处理示例： 定义一个异步任务，在入参为3时模拟抛出异常的情况 @Log4j2 @Component public class AsyncTest { @Async("asyncServiceExecutor") public Future<String> sync(i
JAVA并发编程 之 CountDownLatch、CyclicBarrier、Semaphore、Callable和Future
二一点
04-11 1346
CountDownLatch用法CountDownLatch位于java.util.concurrent包下，利用它可以实现类似计数器的功能。比如有一个任务A，它要等待其他4个任务执行完毕之后才能执行，此时就可以利用CountDownLatch来实现这种功能了。CountDownLatch类只提供了一个构造器：public CountDownLatch(int count) { }; //参数...
谈谈对 java线程池（Executors、ExecutorService、ScheduledExecutorService）和（Callable、Future、CyclicBarrier）的理解
eddyjoe的博客
03-11 872
线程池概念 线程池是实现多线程的一种用法，可以维护多个线程，优化创建和销毁线程的开销达到系统优化性能的目的。 线程池的优点 （1） 降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗； （2） 提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行； （3） 提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进...
Executor、Callable、Future、Lock、辅助类、CompletableFuture
weixin_44677487的博客
11-30 523
文章目录Executor框架浅析Executor框架的两级调度模型Executor框架的结构参考 Executor框架浅析 首先我们得明白一个问题，为什么需要线程池？在java中，使用线程来执行异步任务时，线程的创建和销毁需要一定的开销，如果我们为每一个任务创建一个新的线程来执行的话，那么这些线程的创建与销毁将消耗大量的计算资源。同时为每一个任务创建一个新线程来执行，这样的方式可能会使处于高负荷状态的应用最终崩溃。所以线程池的出现为解决这个问题带来曙光。我们将在线程池中创建若干条线程，当有任务需要执行时就
spring线程池ThreadPoolExecutor配置以及FutureTask的使用
12-14
最代码，http://www.zuidaima.com/share/1724478138158080.htm 的代码及例子
Spring boot基于ScheduledFuture实现定时任务
08-19
主要介绍了Spring boot基于ScheduledFuture实现定时任务,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
SpringBoot 2.x 整合线程池——ThreadPoolTaskExecutor
weixin_43491745的博客
07-29 982
SpringBoot整合ThreadPoolTaskExecutor 1. SpringBoot对线程池的自动装载2. 自定义线程池2.1 根据业务配置不同的线程池2.2 如何使用连接池2.3 如何获取任务的返回值2.4 Runnable异常处理彩蛋——Future\使用lambda表达式彩蛋——若自定义实现线程池，如何获取到各个任务的结果 JAVA && Spring && SpringBoot2.x学习目录 我们在JDK中，可以使用ThreadPoolExecutor提
【Java】SpringBoot中使用ThreadPoolTaskExecutor实现异步多线程
Mr_EvanChen的Blog
07-01 3674
一、配置类 @Configuration public class TaskConfig { @Bean("taskModuleExecutor") public ThreadPoolTaskExecutor taskExecutor() { ThreadPoolTaskExecutor threadPoolTaskExecutor = new ThreadPoolT...
future java 多线程_Java多线程之ThreadPoolExecutor和Future结合使用
weixin_36307549的博客
02-21 343
List> returnFuture = new ArrayList<>();ThreadFactory namedThreadFactory = new ThreadFactoryBuilder().setNameFormat("openAccount-pool-%d").build();ExecutorService pool = new ThreadPoolExecutor...
SpringBoot多线程，使用ThreadPoolExecutor加Guava的ListenableFuture
zzhongcy的专栏
02-27 2294
前提： 日常开发，有很多场景会使用到多线程，比如，我们解析Excel，如果解析出一个3万条数据的Excel表格，需要两部： 1.我们需要先异步解析出所有的数据，前面写过了如何异步处理任务（Spring Boot---(4)SpringBoot异步处理任务）； 2.然后再多线程去处理业务或者插入到数据库； 这里，讲解一下，如何使用多线程，如何调用回调函数。 1、ThreadPo...
SpringBoot对多线程的集成及异步调用,ThreadPoolTaskExecutor类
weixin_46009162的博客
07-08 1707
多线程的集成及异步调用配置多线程ThreadPoolTaskExecutor配置ThreadPoolTaskExecutor参数SpringBoot中的异步调用1：定义任务方法2：在启动类上添加@EnableAsync注解3：回到测试类中编写测试方法test，然后测试4：线程池监控带返回值方法的调用及结果获取：threadPool.submit（ Callable<>()）不带返回值方法执行：threadPool.execute（Runnable()） 配置多线程 ThreadPoolTaskE
SpringBoot 通过FutureTask批量异步处理任务
10-10 1622
FutureTask批量判断结果一、线程池配置properties配置文件加载线程池参数配置类二、异步方法编写三、测试异步方法测试类查看任务状态测试结果result1result2四、问题队列满了抛异常解决方法1.增大队列值2.ThreadPoolExecutor 指定拒绝方式2.1 AbortPolicy(默认)2.2 CallerRunsPolicy2.3 DiscardPolicy 抛弃2.4 DiscardOldestPolicy 抛弃之前的任务五、其他FutureTask源码 一、线程池配置 pr
Future、 CompletableFuture、ThreadPoolTaskExecutor简单实践
weixin_33967071的博客
04-25 1133
一 Future（jdk5引入）      简介： Future接口是Java多线程Future模式的实现，可以来进行异步计算。               可以使用isDone方法检查计算是否完成，或者使用get阻塞住调用线程，直到计算完成返回结果，也可以使用cancel方法停止任务的执行。      简单测试 -  主题 ： Future模式可以理解成：我有一个任务，提交给了Future，Fu...
java方法异步怎样处理
最新发布
07-08
2. 使用`CompletableFuture`：`CompletableFuture`是Java 8引入的一个类，用于处理异步任务和异步结果。你可以使用`CompletableFuture.supplyAsync()`或`CompletableFuture.runAsync()`方法来执行异步方法，并使用回...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值