spring Async的线程池配置 spring@async

转载

墨染青丝 2024-03-17 08:57:24

文章标签 spring Async的线程池配置线程池 Async 工作队列 文章分类 架构后端开发

Spring使用@Async注解

本文讲述@Async注解，在Spring体系中的应用。本文仅说明@Async注解的应用规则，对于原理，调用逻辑，源码分析，暂不介绍。对于异步方法调用，从Spring3开始提供了@Async注解，该注解可以被标注在方法上，以便异步地调用该方法。调用者将在调用时立即返回，方法的实际执行将提交给Spring TaskExecutor的任务中，由指定的线程池中的线程执行。

在项目应用中，@Async调用线程池，推荐使用自定义线程池的模式。自定义线程池常用方案：重新实现接口AsyncConfigurer。

简介

应用场景

同步： 同步就是整个处理过程顺序执行，当各个过程都执行完毕，并返回结果。

异步： 异步调用则是只是发送了调用的指令，调用者无需等待被调用的方法完全执行完毕；而是继续执行下面的流程。例如，在某个调用中，需要顺序调用 A, B, C三个过程方法；如他们都是同步调用，则需要将他们都顺序执行完毕之后，方算作过程执行完毕；如B为一个异步的调用方法，则在执行完A之后，调用B，并不等待B完成，而是执行开始调用C，待C执行完毕之后，就意味着这个过程执行完毕了。在Java中，一般在处理类似的场景之时，都是基于创建独立的线程去完成相应的异步调用逻辑，通过主线程和不同的业务子线程之间的执行流程，从而在启动独立的线程之后，主线程继续执行而不会产生停滞等待的情况。

Spring 已经实现的异常线程池

SimpleAsyncTaskExecutor：不是真的线程池，这个类不重用线程，默认每次调用都会创建一个新的线程。
SyncTaskExecutor：这个类没有实现异步调用，只是一个同步操作。只适用于不需要多线程的地方。
ConcurrentTaskExecutor：Executor的适配类，不推荐使用。如果ThreadPoolTaskExecutor不满足要求时，才用考虑使用这个类。
SimpleThreadPoolTaskExecutor：是Quartz的SimpleThreadPool的类。线程池同时被quartz和非quartz使用，才需要使用此类。
ThreadPoolTaskExecutor ：最常使用，推荐。其实质是对java.util.concurrent.ThreadPoolExecutor的包装。

异步的方法有：

最简单的异步调用，返回值为void
带参数的异步调用，异步方法可以传入参数
存在返回值，常调用返回Future

1.Java中创建线程池

ThreadPoolExecutor类介绍

jdk1.8 源码删减部分内容

package java.util.concurrent;
    /**
     * @param corePoolSize 核心线程数 -> 线程池中保持的线程数量,即使它们是空闲的也不会销毁,
     *        除非设置了{@code allowCoreThreadTimeOut}核心线程超时时间
     * @param maximumPoolSize 最大线程数 -> 线程池中允许接收的最大线程数量
     *        如果设定的数量比系统支持的线程数还要大时,会抛出OOM(OutOfMemoryError)异常
     * @param keepAliveTime 最大存活时间 -> 当前线程数大于核心线程数的时候,
     *        其他多余的线程接收新任务之前的最大等待时间,超过时间没有新任务就会销毁.
     * @param unit {@code keepAliveTime}最大存活时间的单位.eg:TimeUnit.SECONDS
     * @param workQueue 工作队列 -> 保存任务直到任务被提交到线程池的线程中执行.
     * @param threadFactory 线程工厂 -> 当线程池需要创建线程得时候会从线程工厂获取新的实例.
     *        (自定义ThreadFactory可以跟踪线程池究竟何时创建了多少线程,也可以自定义线程的名称、
     *        组以及优先级等信息,甚至可以任性的将线程设置为守护线程.
     *        总之,自定义ThreadFactory可以更加自由的设置线程池中所有线程的状态。)
     * @param handler 当线程数量等于最大线程数并且工作队列已满的时候,再有新的任务添加进来就会进入这个handler,
     *        可以理解为设置拒绝策略（此处不清楚的可以看一下ThreadPoolExecutor中的execute方法的注释）
     */
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
    }

ThreadPoolExecutor的执行流程如下：

spring Async的线程池配置 spring@async_工作队列

主线程提交新任务到线程池
线程池判断当前线程池的线程数和核心线程数的大小,小于就新建线程处理请求;否则继续判断当前工作队列是否已满
如果当前工作队列未满就将任务放到工作队列中;否则继续判断当前线程池的线程数和最大线程数的大小
如果当前线程池的线程数小于最大线程数就新建线程处理请求;否则就调用RejectedExecutionHandler来做拒绝处理.

jdk默认提供四种RejectedExecutionHandler接口的实现

AbortPolicy: 直接抛出RejectedExecutionException异常
CallerRunsPolicy: 交由主线程执行
DiscardOldestPolicy: 抛弃工作队列中旧的任务,将新任务添加进队列;会导致被丢弃的任务无法再次被执行
DiscardPolicy: 抛弃当前任务;会导致被抛弃的任务无法再次被执行

2.Spring中创建线程池

ThreadPoolTaskExecutor类介绍

package org.springframework.scheduling.concurrent;

    public class ThreadPoolTaskExecutor {
        private final Object poolSizeMonitor = new Object(); // 线程池大小锁,保证获取的当前线程池大小的正确性
        private int corePoolSize = 1; // 核心线程数
        private int maxPoolSize = 2147483647; // 最大线程数
        private int keepAliveSeconds = 60; // 最大存活时间
        private int queueCapacity = 2147483647; // 工作队列大小
        private boolean allowCoreThreadTimeOut = false; // 是否允许核心线程超时,false不允许
        private TaskDecorator taskDecorator; // 围绕任务的调用设置一些执行上下文,或者为任务执行提供一些监视/统计
        private ThreadPoolExecutor threadPoolExecutor; // java中的线程池创建类
    ｝

从源码中可以看出ThreadPoolTaskExecutor就是在java中ThreadPoolExecutor的基础上封装的

3.线程池使用示例

3.1基本介绍

1、Spring中启用@Async

// 1、基于Java配置的启用方式：
@Configuration  
@EnableAsync  
public class SpringAsyncConfig { ... }  

// 2、Spring boot启用：
@EnableAsync
@EnableTransactionManagement
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

2、@Async应用默认线程池

Spring应用默认的线程池，指在@Async注解在使用时，不指定线程池的名称。查看源码，@Async的默认线程池为SimpleAsyncTaskExecutor。

3、无返回值调用

基于@Async无返回值调用，直接在使用类，使用方法（建议在使用方法）上，加上注解。若需要抛出异常，需手动new一个异常抛出。

/**
     * 带参数的异步调用 异步方法可以传入参数
     *  对于返回值是void，异常会被AsyncUncaughtExceptionHandler处理掉
     * @param s
     */
    @Async
    public void asyncInvokeWithException(String s) {
        log.info("asyncInvokeWithParameter, parementer={}", s);
        throw new IllegalArgumentException(s);
    }

4、有返回值Future调用

/**
     * 异常调用返回Future
     *  对于返回值是Future，不会被AsyncUncaughtExceptionHandler处理，需要我们在方法中捕获异常并处理
     *  或者在调用方在调用Futrue.get时捕获异常进行处理
     * 
     * @param i
     * @return
     */
    @Async
    public Future<String> asyncInvokeReturnFuture(int i) {
        log.info("asyncInvokeReturnFuture, parementer={}", i);
        Future<String> future;
        try {
            Thread.sleep(1000 * 1);
            future = new AsyncResult<String>("success:" + i);
            throw new IllegalArgumentException("a");
        } catch (InterruptedException e) {
            future = new AsyncResult<String>("error");
        } catch(IllegalArgumentException e){
            future = new AsyncResult<String>("error-IllegalArgumentException");
        }
        return future;
    }

5、有返回值CompletableFuture调用

CompletableFuture 并不使用@Async注解，可达到调用系统线程池处理业务的功能。

JDK5新增了Future接口，用于描述一个异步计算的结果。虽然 Future 以及相关使用方法提供了异步执行任务的能力，但是对于结果的获取却是很不方便，只能通过阻塞或者轮询的方式得到任务的结果。阻塞的方式显然和我们的异步编程的初衷相违背，轮询的方式又会耗费无谓的 CPU 资源，而且也不能及时地得到计算结果。

CompletionStage代表异步计算过程中的某一个阶段，一个阶段完成以后可能会触发另外一个阶段
一个阶段的计算执行可以是一个Function，Consumer或者Runnable。比如：stage.thenApply(x -> square(x)).thenAccept(x -> System.out.print(x)).thenRun(() -> System.out.println())
一个阶段的执行可能是被单个阶段的完成触发，也可能是由多个阶段一起触发

在Java8中，CompletableFuture提供了非常强大的Future的扩展功能，可以帮助我们简化异步编程的复杂性，并且提供了函数式编程的能力，可以通过回调的方式处理计算结果，也提供了转换和组合 CompletableFuture 的方法。

它可能代表一个明确完成的Future，也有可能代表一个完成阶段（ CompletionStage ），它支持在计算完成以后触发一些函数或执行某些动作。
它实现了Future和CompletionStage接口

6、默认线程池的弊端

在线程池应用中，参考阿里巴巴java开发规范：**线程池不允许使用Executors去创建，不允许使用系统默认的线程池，推荐通过ThreadPoolExecutor的方式，这样的处理方式让开发的工程师更加明确线程池的运行规则，规避资源耗尽的风险。Executors各个方法的弊端：

newFixedThreadPool和newSingleThreadExecutor：主要问题是堆积的请求处理队列可能会耗费非常大的内存，甚至OOM。
newCachedThreadPool和newScheduledThreadPool：要问题是线程数最大数是Integer.MAX_VALUE，可能会创建数量非常多的线程，甚至OOM。

@Async默认异步配置使用的是SimpleAsyncTaskExecutor，该线程池默认来一个任务创建一个线程，若系统中不断的创建线程，最终会导致系统占用内存过高，引发OutOfMemoryError错误。针对线程创建问题，SimpleAsyncTaskExecutor提供了限流机制，通过concurrencyLimit属性来控制开关，当concurrencyLimit>=0时开启限流机制，默认关闭限流机制即concurrencyLimit=-1，当关闭情况下，会不断创建新的线程来处理任务。基于默认配置，SimpleAsyncTaskExecutor并不是严格意义的线程池，达不到线程复用的功能。

3.2使用ThreadPoolTaskExecutor

1、pom文件

<!--添加springboot-web依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--添加springboot-test测试依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!--lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

2、config类

我们需要通过SpringBoot的配置类来配置线程池的Bean和对应的参数

@Configuration
@EnableAsync // 允许使用异步方法
public class ThreadPoolConfig {

    @Bean
    public Executor threadPoolTaskExecutor() {
        ThreadPoolTaskExecutor threadPoolTaskExecutor = new ThreadPoolTaskExecutor();
        // 设置核心线程数
        threadPoolTaskExecutor.setCorePoolSize(5);
        // 设置最大线程数
        threadPoolTaskExecutor.setMaxPoolSize(5);
        // 设置工作队列大小
        threadPoolTaskExecutor.setQueueCapacity(2000);
        // 设置线程名称前缀
        threadPoolTaskExecutor.setThreadNamePrefix("threadPoolTaskExecutor-->");
        // 设置拒绝策略.当工作队列已满,线程数为最大线程数的时候,接收新任务抛出RejectedExecutionException异常
        threadPoolTaskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.AbortPolicy());
        // 初始化线程池
        threadPoolTaskExecutor.initialize();
        return threadPoolTaskExecutor;
    }
    
//    @Override
//    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
//        return new MyAsyncExceptionHandler();
//    }
//
//    private static class MyAsyncExceptionHandler implements AsyncUncaughtExceptionHandler {
//
//        /**
//         * 此方法只会处理线程运行异常
//         */
//        @Override
//        public void handleUncaughtException(Throwable throwable, Method method, Object... objects) {
//            log.warn("<<<<<<Exception message : {} >>>>>", throwable.getMessage());
//            log.warn("<<<<<<Method name : {} >>>>>", method.getName());
//            for (Object param : objects) {
//                log.warn("<<<<<<Parameter value : {} >>>>>", param);
//            }
//        }
//    }

    /**
     * 简写方式
     * 
     * @return
     */
    @Override
    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
        return (throwable, method, params) -> {
            log.warn("<<<<<<Exception message : {} >>>>>", throwable.getMessage());
            log.warn("<<<<<<Method name : {} >>>>>", method.getName());
            for (Object param : params) {
                log.warn("<<<<<<Parameter value : {} >>>>>", param);
            }
        };
    }
}

3、Application

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

4、调用方法

@Slf4j
@Service
public class AsyncService {

    @Async
    public void noContent() {
        log.info("这是一个无返回值的方法");
    }

    @Async
    public void noContentHasException(String s) {
        log.info("这是一个有参({})无返回值的方法, 但是有异常的方法", s);
        throw new RuntimeException("异步运行时异常");
    }

    @Async
    public CompletableFuture<String> haveContent() {
        String str = "返回值";
        log.info("这是一个有返回值的方法，返回值为：{}", str);
        return CompletableFuture.completedFuture(str);
    }
}

测试类

@RunWith(SpringRunner.class)
@SpringBootTest
public class AsyncTest {

    @Autowired
    private AsyncService asyncService;

    @Test
    public void test() {
        System.out.println("-----------无参无返回值,方法执行-----------");
        asyncService.noContent();
        System.out.println("-----------无参无返回值,方法执行完成-----------");

        System.out.println("-----------有参无返回值有异常,方法执行-----------");
        asyncService.noContentHasException("我是参数");
        System.out.println("-----------有参无返回值有异常,方法执行完成-----------");

        System.out.println("-----------无参有返回值,方法执行-----------");
        CompletableFuture<String> str = asyncService.haveContent();
        try {
            System.out.println(str.get());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
        System.out.println("-----------无参有返回值,方法执行完成-----------");

        // 抛出非异步异常
        throw new RuntimeException("非异步运行时异常");
    }
}

-----------无参无返回值,方法执行-----------
-----------无参无返回值,方法执行完成-----------
-----------有参无返回值有异常,方法执行-----------
-----------有参无返回值有异常,方法执行完成-----------
-----------无参有返回值,方法执行-----------
2019-12-27 11:32:23.367  INFO 452 --- [askExecutor-->3] c.alsb.exception.service.impl.AsyncService  : 这是一个有返回值的方法，返回值为：返回值
2019-12-27 11:32:23.367  INFO 452 --- [askExecutor-->1] c.alsb.exception.service.impl.AsyncService  : 这是一个无返回值的方法
2019-12-27 11:32:23.367  INFO 452 --- [askExecutor-->2] c.alsb.exception.service.impl.AsyncService  : 这是一个有参(我是参数)无返回值的方法, 但是有异常的方法
返回值
-----------无参有返回值,方法执行完成-----------
2019-12-27 11:32:23.368  WARN 452 --- [askExecutor-->2] c.a.exception.config.ThreadPoolConfig    : <<<<<<Exception message : 异步运行时异常 >>>>>
2019-12-27 11:32:23.368  WARN 452 --- [askExecutor-->2] c.a.exception.config.ThreadPoolConfig    : <<<<<<Method name : noContentHasException >>>>>
2019-12-27 11:32:23.368  WARN 452 --- [askExecutor-->2] c.a.exception.config.ThreadPoolConfig    : <<<<<<Parameter value : 我是参数 >>>>>

java.lang.RuntimeException: 非异步运行时异常

	at com.alsb.exception.AsyncTest.test(AsyncTest.java:43)
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	..................................

注意：因为显示名称长度限制的原因我们看到的是askExecutor–>1,
但是通过在方法中打印当前线程的名字得知确实是我们设置的线程threadPoolTaskExecutor–>1

5、获取异步返回值get方法介绍

/**
     * 如有必要，最多等待给定时间以完成此将来，然后返回其结果（如果有）。
     *
     * @param timeout 等待的最长时间
     * @param unit 超时参数的时间单位
     * @return 结果值
     * @throws CancellationException 如果这个未来被取消了
     * @throws ExecutionException 如果这个未来异常完成
     * @throws InterruptedException 如果当前线程在等待时被中断
     * @throws TimeoutException 如果等待超时
     */
    public T get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
        Object r;
        long nanos = unit.toNanos(timeout);
        return reportGet((r = result) == null ? timedGet(nanos) : r);
    }

3.3使用ThreadPoolExecutor

1、在config类中增加如下配置

@Bean
    public Executor myThreadPool() {
        // 设置核心线程数
        int corePoolSize = 5;
        // 设置最大线程数
        int maxPoolSize = 5;
        // 设置工作队列大小
        int queueCapacity = 2000;
        // 最大存活时间
        long keepAliveTime = 30;
        // 设置线程名称前缀
        String threadNamePrefix = "myThreadPool-->";
        // 设置自定义拒绝策略.当工作队列已满,线程数为最大线程数的时候,接收新任务抛出RejectedExecutionException异常
        RejectedExecutionHandler rejectedExecutionHandler = new RejectedExecutionHandler() {
            @Override
            public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
                throw new RejectedExecutionException("自定义的RejectedExecutionHandler");
            }
        };
        // 自定义线程工厂
        ThreadFactory threadFactory = new ThreadFactory() {
            private int i = 1;

            @Override
            public Thread newThread(Runnable r) {
                Thread thread = new Thread(r);
                thread.setName(threadNamePrefix + i);
                i++;
                return thread;
            }
        };
        // 初始化线程池
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(corePoolSize, maxPoolSize,
                keepAliveTime, TimeUnit.SECONDS, new LinkedBlockingQueue<>(queueCapacity),
                threadFactory, rejectedExecutionHandler);
        return threadPoolExecutor;
    }

可以看到我们在config类中配置了两个线程池,如果我们想要指定使用其中一个线程池的需使用如下方式
当未指明使用哪个线程池的时候会优先使用ThreadPoolTaskExecutor
同时也可以配置bean的名称@Bean(“myThreadPool”)

2、在AsyncService类中添加方法

@Async("myThreadPool")
    public void myThreadPool() {
        log.info("测试ThreadPoolExecutor，线程名称：{}", Thread.currentThread().getName());
    }

3、测试

@Test
    public void testMyThreadPool() {
        System.out.println("myThreadPool方法运行中");
        asyncService.myThreadPool();
    }

输出

myThreadPool方法运行中
2019-12-27 13:58:42.136  INFO 19112 --- [yThreadPool-->1] c.alsb.exception.service.impl.AsyncService  : 测试ThreadPoolExecutor，线程名称：myThreadPool-->1

3.4 自定义ThreadPoolTaskExecutor

1、创建MyThreadPoolTaskExecutor

@Slf4j
public class MyThreadPoolTaskExecutor extends ThreadPoolTaskExecutor {

    @Override
    public void execute(Runnable task) {
        logThreadPoolStatus();
        super.execute(task);
    }

    @Override
    public void execute(Runnable task, long startTimeout) {
        logThreadPoolStatus();
        super.execute(task, startTimeout);
    }

    @Override
    public Future<?> submit(Runnable task) {
        logThreadPoolStatus();
        return super.submit(task);
    }

    @Override
    public <T> Future<T> submit(Callable<T> task) {
        logThreadPoolStatus();
        return super.submit(task);
    }

    @Override
    public ListenableFuture<?> submitListenable(Runnable task) {
        logThreadPoolStatus();
        return super.submitListenable(task);
    }

    @Override
    public <T> ListenableFuture<T> submitListenable(Callable<T> task) {
        logThreadPoolStatus();
        return super.submitListenable(task);
    }
    
    /**
     * 在线程池运行的时候输出线程池的基本信息
     */
    private void logThreadPoolStatus() {
        log.info("核心线程数:{}, 最大线程数:{}, 当前线程数: {}, 活跃的线程数: {}",
        getCorePoolSize(), getMaxPoolSize(), getPoolSize(), getActiveCount());
    }
}

我们可以在自定义的ThreadPoolTaskExecutor中,输出一些线程池的当前状态,包括所有上面介绍的参数.

2、在config类中增加配置

@Bean("myThreadPoolTaskExecutor")
    public Executor myThreadPoolTaskExecutor() {
        ThreadPoolTaskExecutor threadPoolTaskExecutor = new MyThreadPoolTaskExecutor();
        // 设置核心线程数
        threadPoolTaskExecutor.setCorePoolSize(5);
        // 设置最大线程数
        threadPoolTaskExecutor.setMaxPoolSize(5);
        // 设置工作队列大小
        threadPoolTaskExecutor.setQueueCapacity(2000);
        // 设置线程名称前缀
        threadPoolTaskExecutor.setThreadNamePrefix("myThreadPoolTaskExecutor-->");
        // 设置拒绝策略.当工作队列已满,线程数为最大线程数的时候,接收新任务抛出RejectedExecutionException异常
        threadPoolTaskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.AbortPolicy());
        // 初始化线程池
        threadPoolTaskExecutor.initialize();
        return threadPoolTaskExecutor;
    }

只需将ThreadPoolTaskExecutor的实例化对象换成自定义的即可

3.5基于@Async返回值的调用

1、增加一个实体对象

public class HelloEntity {
    private String helloStr;

    public String getHelloStr() {
        return helloStr;
    }

    public void setHelloStr(String helloStr) {
        this.helloStr = helloStr;
    }
}

2、在Asuncservice中增加以下方法

@Async("myThreadPoolTaskExecutor")
    public Future<HelloEntity> getHelloString() {
        log.info("start getHelloString");
        HelloEntity helloEntity = new HelloEntity();
        helloEntity.setHelloStr("Say hello to little wang");
        System.out.println(Thread.currentThread().getName());
        log.info("end getHelloString");
        return new AsyncResult<>(helloEntity);
    }

AsyncResult 是spring封装的和@Async配合使用的异步返回结果

3、测试

@Test
    public void testGetHelloString() throws Exception {
        Future<HelloEntity> helloString = asyncService.getHelloString();
        HelloEntity helloEntity = helloString.get();
        System.out.println(helloEntity.getHelloStr());
    }

输出

2019-12-27 14:28:29.188  INFO 2252 --- [           main] c.a.e.config.MyThreadPoolTaskExecutor    : 核心线程数:5, 最大线程数:5, 当前线程数: 0, 活跃的线程数: 0
2019-12-27 14:28:29.196  INFO 2252 --- [askExecutor-->1] c.a.exception.service.impl.AsyncService  : start getHelloString
myThreadPoolTaskExecutor-->1
2019-12-27 14:28:29.197  INFO 2252 --- [askExecutor-->1] c.a.exception.service.impl.AsyncService  : end getHelloString
Say hello to little wang
2019-12-27 14:28:29.206  INFO 2252 --- [       Thread-2] c.a.e.config.MyThreadPoolTaskExecutor    : Shutting down ExecutorService 'myThreadPoolTaskExecutor'
2019-12-27 14:28:29.206  INFO 2252 --- [       Thread-2] o.s.s.concurrent.ThreadPoolTaskExecutor  : Shutting down ExecutorService 'threadPoolTaskExecutor'

3.5 使用默认配置的线程池

我们不需要配置任何config类只需要在启动类中加上以下注解

@SpringBootApplication
@EnableAsync // 允许使用异步方法
public class ThreadPoolApplication {

    public static void main(String[] args) {
        SpringApplication.run(ThreadPoolApplication.class, args);
    }

}
----------------------
	@Async
    public void sayHello() {
        logger.info("start say hello");
        System.out.println(Thread.currentThread().getName());
        System.out.println("hello");
        logger.info("end say hello");
    }
------------------------
    @Test
    public void testSayHello() throws Exception {
        helloService.sayHello();
    }

默认使用的就是ThreadPoolTaskExecutor这个类，当我们在项目中使用线程池的时候,还是要根据项目的实际情况来设置线程池的参数

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：建完表AUTO_INCREMENT 建完表添加默认值约束

下一篇：unity3d fps框架插件 unity3d fps教程

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯