@Async 异步任务自定义线程池的配置方法和 @Scheduled 定时任务自定义线程池的配置方式

最新推荐文章于 2024-06-09 15:28:54 发布
最新推荐文章于 2024-06-09 15:28:54 发布
阅读量1.8k 收藏 36
点赞数 6
文章标签： java 多线程 quartz spring 队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Rambo_Yang/article/details/113943579
版权

文章目录

一、定时和异步业务场景描述

  • 在项目的开发过程中，定时任务调度的场景是非常常见的项目功能，随着业务的不断迭代和日益复杂化，可能一个项目中还会出现定时任务调度和异步接口调度共同存在的情况。

  • 本案例主要讲述如何通过 @Scheduled 注解来完成定时任务的调度工作，以及非定时任务的接口异步任务的自定义线程池的配置工作。

二、定时调度任务的实现方式

  1. 在启动类添加 @EnableScheduling 注解，用以允许应用程序启动定时任务调度器

    /**
 * Copyright (C), 1998-2021, Shenzhen Rambo Technology Co., Ltd
 * Spring Boot Scheduled Sample 演示启动类
 *
 * @author  Rambo
 * @date    2021/02/19 17:06
 * @since   1.0.0.1
 */
@SpringBootApplication
@EnableScheduling
public class SpringBootScheduleSampleApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringBootScheduleSampleApplication.class, args);
    }

  2. 编写定时任务

    /**
 * Copyright (C), 1998-2021, Shenzhen Rambo Technology Co., Ltd
 * 定时任务组件类
 *
 * @author  Rambo
 * @date    2021/2/20 09:50
 * @since   1.0.0.1
 */
@Component
@Slf4j
public class ScheduledTasks {
    @Scheduled(cron = "0/1 * * * * ?")
    public void scheduledCron1() throws InterruptedException {
        // 模拟该任务响应时间较长，导致所有采用 @Scheduled 注解调度的定时任务都被阻塞
        TimeUnit.SECONDS.sleep(10);
        log.info("-------------> 调度线程名称：[{}]，被调度方法名称：[ScheduledTasks1.scheduledCron1()]，执行频率：1秒/次，当前时间：[{}]", Thread.currentThread().getName(), DateUtil.now());
    }

    @Scheduled(cron = "0/2 * * * * ?")
    public void scheduledCron2() {
        log.info("-------------> 调度线程名称：[{}]，被调度方法名称：[ScheduledTasks1.scheduledCron2()]，执行频率：2秒/次，当前时间：[{}]", Thread.currentThread().getName(), DateUtil.now());
    }

    @Scheduled(cron = "0/3 * * * * ?")
    public void scheduledCron3() {
        log.info("-------------> 调度线程名称：[{}]，被调度方法名称：[ScheduledTasks1.scheduledCron3()]，执行频率：3秒/次，当前时间：[{}]", Thread.currentThread().getName(), DateUtil.now());
    }
}

    P.S
    @Scheduled 注解所支持的参数

    参数属性属性描述
    croncron表达式，指定任务在特定时间执行
    fixedDelay表示上一次任务执行完成后多久再次执行，参数类型为long，单位ms
    fixedDelayString与fixedDelay含义一样，只是参数类型变为String
    fixedRate表示按一定的频率执行任务，参数类型为long，单位ms
    fixedRateString与fixedRate的含义一样，只是将参数类型变为String
    initialDelay表示延迟多久再第一次执行任务，参数类型为long，单位ms
    initialDelayString与initialDelay的含义一样，只是将参数类型变为String
    zone时区，默认为当前时区，一般没有用到

  3. 查看启动效果
    1

三、定时调度任务的问题描述

  • 按照以上方式配置，不管在哪个类中，只要采用 @Scheduled 注解来调度任务方法，所有的任务方法都默认使用同一个线程池中的同一个线程来进行任务调度。

  • 所有采用 @Scheduled 注解的方法，可以交替执行（表面上），但是如果任何一个被调度的方法响应时间过长或者执行时间过长，将会导致所有被 @Scheduled 注解调度的任务呈阻塞状态。

  • 一旦出现阻塞状态，所谓的定时调度也就失去了原本预定的意义，需要特别注意。

四、定时调度多线程解决方案（方案一）

  1. 配置文件配置任务调度线程池的配置信息

    # 自定义调度任务线程池
schedule-pool:
  # 核心线程池大小
  core-pool-size: 20
  # 自定义线程名称
  thread-name-prefix: SCHEDULE-BIZ-
  # 设置终止等待时间：秒
  await-termination-time: 60
  # 线程结束前，是否等待线程队列中的任务执行完成
  wait-tasks-complete: true
  # 线程拒绝策略（ABORT_POLICY、CALLER_RUNS_POLICY、DISCARD_OLDEST_POLICY、DISCARD_POLICY）
  rejected-policy: CALLER_RUNS_POLICY

  2. 创建配置类读取配置文件的配置信息

    /**
 * Copyright (C), 1998-2021, Shenzhen Rambo Technology Co., Ltd
 * "@Scheduled" 注解定时调度器线程池配置类
 *
 * @author  Rambo
 * @date    2021/2/20 16:56
 * @since   1.0.0.1
 */
@Component
@ConfigurationProperties(prefix = "schedule-pool")
@Data
public class SchedulePoolConfig {

    /** 核心线程池大小*/
    private int corePoolSize = 1;

    /** 自定义线程名称*/
    private String threadNamePrefix = "SCHEDULE";

    /** 设置终止等待时间：秒*/
    private int awaitTerminationTime = 30;

    /** 线程结束前，是否等待线程队列中的任务执行完成*/
    private boolean waitTasksComplete = true;

    /** 线程拒绝策略 RejectedPolicy.java*/
    private String rejectedPolicy = "ABORT_POLICY";
}

  3. 根据自定义线程配置信息创建 ThreadPoolTaskScheduler 线程池

    /**
 * Copyright (C), 1998-2021, Shenzhen Rambo Technology Co., Ltd
 * 线程拒绝策略常量类
 *
 * @author  Rambo
 * @date    2021/2/22 14:14
 * @since   1.0.0.1
 */
public interface RejectedPolicy {
    /** 默认的拒绝策略，会 throw RejectedExecutionException 拒绝*/
    String ABORT_POLICY = "ABORT_POLICY";

    /** 提交任务的主线程自己去执行该任务*/
    String CALLER_RUNS_POLICY = "CALLER_RUNS_POLICY";

    /** 丢弃最老的任务，然后把新任务加入到工作队列*/
    String DISCARD_OLDEST_POLICY = "DISCARD_OLDEST_POLICY";

    /** 直接丢弃任务，没有任何异常抛出*/
    String DISCARD_POLICY = "DISCARD_POLICY";
}    

    /**
 * Copyright (C), 1998-2021, Shenzhen Rambo Technology Co., Ltd
 * 多线程并发调度任务配置类
 *
 * 此配置弊端：线程池大小无界限、默认线程队列长度 16
 *
 * @author  Rambo
 * @date    2021/2/20 10:36
 * @since   1.0.0.1
 */
@Configuration
@Slf4j
public class ScheduleThreadPoolExecutor implements SchedulingConfigurer {

    @Resource
    private SchedulePoolConfig poolConfig;

    @Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
        // 未自定义线程池，线程池没有界限，有出现 OOM 的风险
        // taskRegistrar.setScheduler(Executors.newScheduledThreadPool(5));

        // 自定义线程池
        taskRegistrar.setScheduler(taskScheduler());
    }

    /**
     * destroyMethod = shutdown 进程结束前，执行完成等待队列中的所有任务后退出应用程序
     *
     * @author  Rambo
     * @date    2021/2/22 14:26
     * @return  org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler
     */
    @Bean(destroyMethod = "shutdown")
    public ThreadPoolTaskScheduler taskScheduler() {
        // 1. 实例化任务调度线程
        ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
        // 2. 设置线程池大小
        scheduler.setPoolSize(poolConfig.getCorePoolSize());
        // 3. 设置线程名称
        scheduler.setThreadNamePrefix(poolConfig.getThreadNamePrefix());
        // 4. 设置等待终止时间：秒
        scheduler.setAwaitTerminationSeconds(poolConfig.getAwaitTerminationTime());
        // 5. 进程结束前，等待线程队列中的任务执行完成
        scheduler.setWaitForTasksToCompleteOnShutdown(poolConfig.isWaitTasksComplete());
        // 6. 设置拒绝策略
        // setRejectedExecutionHandler：当线程池已经达到 max size 的时候，如何处理新任务
        // AbortPolicy          默认的拒绝策略，会 throw RejectedExecutionException 拒绝
        // CallerRunsPolicy     提交任务的主线程自己去执行该任务
        // DiscardOldestPolicy  丢弃最老的任务，其实就是把最早进入工作队列的任务丢弃，然后把新任务加入到工作队列
        // DiscardPolicy        相当大胆的策略，直接丢弃任务，没有任何异常抛出
        scheduler.setRejectedExecutionHandler(chooseRejectedPolicy(poolConfig.getRejectedPolicy()));
        // 7. 设置异常输出格式
        scheduler.setErrorHandler(throwable -> log.error("调度任务发生异常", throwable));
        log.info("------>== @Schedule 业务处理线程配置成功，核心线程池：[{}]，程名称前缀：[{}] ==<------",poolConfig.getCorePoolSize(), poolConfig.getThreadNamePrefix());
        return scheduler;
    }

    /**
     * 实例化线程拒绝策略
     *
     * @author  Rambo
     * @date    2021/2/22 14:23
     * @param	rejectedPolicy  拒绝策略枚举
     * @return  java.util.concurrent.RejectedExecutionHandler
     */
    private RejectedExecutionHandler chooseRejectedPolicy(String rejectedPolicy) {
        RejectedExecutionHandler handler;
        switch (rejectedPolicy) {
            case RejectedPolicy.CALLER_RUNS_POLICY:
                handler = new ThreadPoolExecutor.CallerRunsPolicy();
                break;
            case RejectedPolicy.DISCARD_OLDEST_POLICY:
                handler = new ThreadPoolExecutor.DiscardOldestPolicy();
                break;
            case RejectedPolicy.DISCARD_POLICY:
                handler = new ThreadPoolExecutor.DiscardPolicy();
                break;
            default:
                handler = new ThreadPoolExecutor.AbortPolicy();
                break;
        }
        return handler;
    }
}

    2

弊端：

  • 如果自定义线程池配置不合理，调度任务数量大于线程池数量，并且各个线程都处于工作状态，那么新来的任务将会被阻塞，等待前面的线程执行完成后，再被执行

  • 线程池大小无界限、默认线程队列长度 16

五、异步多线程程序实现方式

  1. 应用程序启动类或者需要异步的实现类上添加 @EnableAsync 注解

    /**
 * Copyright (C), 1998-2021, Shenzhen Rambo Technology Co., Ltd
 * Spring Boot Scheduled Sample 演示启动类
 *
 * @author  Rambo
 * @date    2021/02/19 17:06
 * @since   1.0.0.1
 */
@SpringBootApplication
@EnableScheduling
@EnableAsync
public class SpringBootScheduleSampleApplication {

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

  2. 配置文件配置异步任务线程池的配置信息

    # 自定义异步任务线程池
async-pool:
  # 核心线程池大小
  core-pool-size: 20
  # 最大线程数大小
  maximum-pool-size: 40
  # 活跃时间：秒
  keep-alive-seconds: 300
  # 线程等待队列大小
  queue-capacity: 50
  # 自定义线程名称前缀
  thread-name-prefix: ASYNC-BIZ-
  # 设置终止等待时间：秒
  await-termination-time: 60
  # 线程结束前，是否等待线程队列中的任务执行完成
  wait-tasks-complete: true

  3. 创建配置类读取配置文件异步任务线程池的配置信息

    /**
 * Copyright (C), 1998-2021, Shenzhen Rambo Technology Co., Ltd
 * @Async 注解异步线程池配置类，如果需要根据不同业务指定多个不同的异步线程池，则可以通过 @Async 指定不同自定义线程池的方式实现
 *
 * @author  Rambo
 * @date    2021/2/22 11:28
 * @since   1.0.0.1
 */
@Configuration
@ConfigurationProperties(prefix = "async-pool")
@Data
public class AsyncPoolConfig {
    /** 核心线程池大小*/
    private int corePoolSize = 10;

    /** 最大线程数大小*/
    private int maximumPoolSize = 20;

    /** 活跃时间：秒*/
    private int keepAliveSeconds = 60;

    /** 线程等待队列大小*/
    private int queueCapacity = 30;

    /** 自定义线程名称前缀*/
    private String threadNamePrefix = "ASYNC-";

    /** 设置终止等待时间：秒*/
    private int awaitTerminationTime = 30;

    /** 线程结束前，是否等待线程队列中的任务执行完成*/
    private boolean waitTasksComplete = true;
}

  4. 根据自定义线程配置信息创建 ThreadPoolTaskExecutor 线程池

    /**
 * Copyright (C), 1998-2021, Shenzhen Rambo Technology Co., Ltd
 * "@Async" 注解 异步任务自定义线程池装配类
 *
 * @author  Rambo
 * @date    2021/1/13 18:55
 * @since   1.0.0.1
 */
@Configuration
@Slf4j
public class AsyncThreadPoolExecutor {

    @Resource
    private AsyncPoolConfig poolConfig;

    @Bean
    public Executor asyncExecutor() {
        // 1. 实例化异步任务线程池
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        // 2. 设置核心线程池大小
        executor.setCorePoolSize(poolConfig.getCorePoolSize());
        // 3. 设置最大线程数
        executor.setMaxPoolSize(poolConfig.getMaximumPoolSize());
        // 4. 设置线程等待队列大小
        executor.setQueueCapacity(poolConfig.getQueueCapacity());
        // 5. 设置活跃时间：秒
        executor.setKeepAliveSeconds(poolConfig.getKeepAliveSeconds());
        // 6. 设置线程名字前缀
        executor.setThreadNamePrefix(poolConfig.getThreadNamePrefix());
        // setRejectedExecutionHandler：当线程池已经达到 max size 的时候，如何处理新任务
        // AbortPolicy          默认的拒绝策略，会 throw RejectedExecutionException 拒绝
        // CallerRunsPolicy     提交任务的主线程自己去执行该任务
        // DiscardOldestPolicy  丢弃最老的任务，其实就是把最早进入工作队列的任务丢弃，然后把新任务加入到工作队列
        // DiscardPolicy        相当大胆的策略，直接丢弃任务，没有任何异常抛出
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        // 7. 设置等待终止时间：秒
        executor.setAwaitTerminationSeconds(poolConfig.getAwaitTerminationTime());
        // 8. 进程结束前，等待线程队列中的任务执行完成
        executor.setWaitForTasksToCompleteOnShutdown(poolConfig.isWaitTasksComplete());
        // 9. 手动初始化线程池
        executor.initialize();
        log.info("------>== @Async 业务处理线程配置成功，核心线程池：[{}]，最大线程池：[{}]，队列容量：[{}]，线程名称前缀：[{}] ==<------",poolConfig.getCorePoolSize(), poolConfig.getMaximumPoolSize(), poolConfig.getQueueCapacity(), poolConfig.getThreadNamePrefix());
        return executor;
    }

    @Bean
    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
        return (throwable, method, objects) -> {
            log.error("@Async 业务 ----> 异常精简信息：[{}]，异常Throwable：{}", throwable.getMessage(), throwable);
            log.error("@Async 业务 ----> 触发异常的方法名称：{}", method.getName());
        };
    }
}

  5. 在需要使用异步线程的方法上添加 @Async(value = "自定义ThreadPoolTaskExecutor的 Bean 的方法名")

    /**
 * Copyright (C), 1998-2021, Shenzhen Rambo Technology Co., Ltd
 * 异步任务线程演示控制器
 *
 * @author  Rambo
 * @date    2021/2/22 16:09
 * @since   1.0.0.1
 */
@RestController
@RequestMapping("/async")
@Slf4j
public class AsyncController {

    @GetMapping("/info")
    @Async(value = "asyncExecutor")
    public void info() throws InterruptedException {
        log.info("-------------> 调度线程名称：[{}]，被调度方法名称：[AsyncController.info()]，当前时间：[{}]", Thread.currentThread().getName(), DateUtil.now());
        // 模拟业务任务处理耗时
        TimeUnit.SECONDS.sleep(5);
    }
}

  6. 频繁疯狂请求的效果

    3

六、定时调度多线程解决方案（方案二）

  1. 根据上一步骤，我们可以知道，采用 @Async 注解也可以自定义线程池来实现异步任务

  2. 那么我们是否可以将 @Async 注解 和 @Schedule 注解同时使用，来解决默认 @Schedule 注解同一线程池同一线程处理的弊端？

  3. 代码实现

    @Async(value = "asyncExecutor")
@Scheduled(cron = "0/2 * * * * ?")
public void scheduledCron2() throws InterruptedException {
    log.info("-------------> 调度线程名称：[{}]，被调度方法名称：[ScheduledTasks1.scheduledCron2()]，执行频率：2秒/次，当前时间：[{}]", Thread.currentThread().getName(), DateUtil.now());
    // 模拟该任务响应时间
    TimeUnit.SECONDS.sleep(20);
}

  4. 调度效果

    4

Ramboooooooo
关注
  • 6
    点赞
  • 踩
  • 36
    收藏
    觉得还不错? 一键收藏
  • 15
    评论
玩转SpringBoot之定时任务Scheduled线程池配置
Sdj356512265的博客
03-31 8788
对于定时任务，在SpringBoot中只需要使用@Scheduled 这个注解就能够满足需求，它的出现也给我们带了很大的方便，我们只要加上该注解，并且根据需求设置好就可以使用定时任务了。 但是，我们需要注意的是，@Scheduled 并不一定会按时执行。 因为使用@Scheduled 的定时任务虽然是异步执行的，但是，不同的定时任务之间并不是并行的！！！！！！！！ 在其中一个定时任务没有执行完之前，其他的定时任务即使是到了执行时间，也是不会执行的，它们会进行排队。 也就是如果你想你不同的定时任务互不
spring boot下,@Scheduled定时任务的线程执行策略（配置Scheduled定时任务多线程池执行的方法）
weixin_44873050的博客
11-17 2419
spring boot定时任务:一,@Scheduled默认以单线程执行所有任务1.前期准备2.运行结果：3.解决方法：重点： spring boot中,开启定时任务只需要两步: 配置启动类 在需要定时的方法上添加@Scheduled注解 这里就不再赘述,有需要了解具体步骤,请移步spring boot 使用 @Scheduled 执行定时任务,今天主要讨论的,是spring boot定时任务的线程问题。 在需求多样且复杂的实际业务场景中,对定时执行的方法要求也多有不同;其中有一些方法,可能需要每隔5-
SpringBoot项目中@Scheduled定时任务配置线程池
m0_46440313的博客
08-16 7936
使用spring的定时器 @Scheduled 的话，因为 @Scheduled 默认是单线程执行的，所以在需要的时候，我们可以设置一个线程池去执行定时任务。
SpringBoot-异步编程：@Async原理、使用及自定义线程池
小孔靠得住的博客
05-19 1278
​ 在Spring Boot中，使用@Async注解进行异步编程是一种非常实用的特性，它可以帮助我们提升应用的响应速度，尤其是在执行一些耗时操作（如大文件处理、网络请求、数据库批量操作等）时。异步方法可以在后台线程中执行，而不需要阻塞主线程，从而提高了应用的并发能力和用户体验。
@Scheduled和@Async解析与自定义线程池
qq_39173672的博客
08-09 2620
@Scheduled和@Async注解解析与自定义线程池
java 定时器线程池（ScheduledThreadPoolExecutor）的实现
08-19
主要介绍了java 定时器线程池（ScheduledThreadPoolExecutor）,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
@scheduled任务调度使用详解及@scheduled与多线程和@Async异步任务结合使用
12-13
在Spring Boot框架中，`@Scheduled`注解是用于实现定时任务的核心工具，它使得开发者可以轻松地在应用中...通过自定义线程池和配置`TaskExecutor`，我们可以更好地控制任务的执行方式，从而优化应用程序的运行效率。
Java多线程之定时任务 以及 SpringBoot多线程实现定时任务——异步任务
03-12
1. SpringBoot 自定义线程池以及多线程间的异步调用（@Async、@EnableAsync） 2.Java多线程之定时任务 以及 SpringBoot多线程实现定时任务 3.@EnableScheduling 与 @Scheduled
Spring Boot中配置定时任务、线程池与多线程池执行的方法
08-25
总的来说，Spring Boot通过`@EnableScheduling`、`@Scheduled`、`@EnableAsync`和`ThreadPoolTaskExecutor`等工具，为我们提供了灵活的定时任务和线程池配置能力，可以根据实际需求来定制任务执行策略，优化系统性能...
Spring定时任务@Scheduled例子
07-01
`task:executor`则是Spring中用于处理异步任务的bean，它可以被`@Async`和`@Scheduled`注解的方法使用。配置`task:executor`可以定制线程池属性，如核心线程数、最大线程数、线程存活时间等。 5. **测试说明** 在...
SpringBoot实现定时任务和异步调用
08-26
SpringBoot实现定时任务和异步调用 SpringBoot框架提供了强大的功能来实现定时任务和异步调用，这在业务场景中非常常见。例如，在电商平台中，需要定时发送邮件、短信、统计监控数据等操作，而在订单流程中，需要...
自定义Java-ScheduledExecutorService定时器.jar
01-29
这是一个jar，很秀。自定义的一个Java定时器工具类。主要是结合Spring Boot一起使用，并在Spring Boot启动的时候一起启动运行。
线程池实现@Scheduled原理分析探索
qq_33803292的博客
10-30 198
@Scheduled
@Scheduled教程1-- 指定线程池运行定时任务
MyBoBo
01-28 3621
1. 未指定线程池 需要注意的@Scheduled默认情况下只有一个线程，并不能同时运行多个任务，分析源码可以看到 运行demo 在控制台我们可以看到打印出来的线程名称 2. 指定线程池运行定时任务 自定义一个线程工厂继承ThreadFactory进行线程配置 package com.example.demo; import lombok.extern.log4j.Log4j; import java.util.concurrent.ThreadFactory; import
springboot定时任务，异步调用，自定义线程池和优雅关闭，Future接口主线程等子线程
qq120631157的博客
02-28 2825
springboot定时任务，异步调用，自定义线程池和优雅关闭，Future接口主线程等子线程
Spring 定时任务@Scheduled 与异步@Async及线程池配置
Ricardo.M.Yu的博客
11-16 2151
Spring 定时任务@Scheduled
SpringBoot中@Scheduled注解默认单线程，改为多线程线程池
最新发布
【小石头的茅坑】
06-09 4万+
Spring Boot 中@Scheduled是单线程还是多线程？
Spring自定义@Scheduled
MieMieFly的专栏
06-16 588
如果想让定时任务分到同一个包里,根据执行参数来控制是否执行,可以自定义个@Scheduled. 1.写个接口命名为MyScheduled,内容参照@Scheduled接口 @Target({ElementType.METHOD, ElementType.ANNOTATION_TYPE}) @Retention(RetentionPolicy.RUNTIME) @Scheduled @Repeatable(MySchedules.class) public @interface MyScheduled
ThreadPoolTaskExecutor使用说明
weixin_30920091的博客
03-07 1674
当我们需要实现并发、异步等操作时，通常都会使用到ThreadPoolTaskExecutor，现对其使用稍作总结。 springboot 配置： 提交任务 无返回值的任务使用execute(Runnable) 有返回值的任务使用submit(Runnable) 处理流程 当一个任务被提交到线程池时，首先查看线程池的核心线程是否都在执行任务，否就选择一条线程执行任务...
@Async怎么自定义线程池
03-22
您可以使用@Async注释来异步执行方法，以便在调用该方法时不会阻塞主线程。要自定义线程池，您可以使用@Async注释的executor属性。例如，您可以使用以下代码定义一个自定义线程池： @Configuration @EnableAsync public class AsyncConfig implements AsyncConfigurer { @Override public Executor getAsyncExecutor() { ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor(); executor.setCorePoolSize(10); executor.setMaxPoolSize(100); executor.setQueueCapacity(10); executor.setThreadNamePrefix("MyExecutor-"); executor.initialize(); return executor; } } 在这个例子中，我们定义了一个名为MyExecutor的线程池，它有10个核心线程和100个最大线程。它还有一个队列容量为10的队列，以便在所有线程都在使用时，可以将任务放入队列中等待执行。您可以根据需要调整这些值。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 15
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值