SpringBoot—自定义线程池及并发定时任务模板

最新推荐文章于 2024-08-14 11:40:55 发布
最新推荐文章于 2024-08-14 11:40:55 发布
阅读量842 收藏 3
点赞数 1
分类专栏： 开发模板总结 Spring & SpringBoot等框架技术 JAVA核心技术 文章标签： SpringBoot定时 java 定时任务并发 java 自定义线程池模板 定时任务并发执行 Spring BOOT
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Andya_net/article/details/106425501
版权

关注微信公众号：CodingTechWork，一起学习进步。
在这里插入图片描述

介绍

  在项目开发中，经常遇到定时任务，今天通过自定义多线程池总结一下SpringBoot默认实现的定时任务机制。

定时任务模板

pom依赖

<dependencies>
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter</artifactId>
	</dependency>
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-test</artifactId>
		<scope>test</scope>
	</dependency>
	//线程池用到
	<dependency>
    	<groupId>com.google.guava</groupId>
        <artifactId>guava</artifactId>
        <version>22.0</version>
    </dependency>
    //@Slf4j注解用到
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
        <version>1.18.4</version>
    </dependency>
</dependencies>

自定义线程池模板

package com.example.andya.demo.conf;

import com.google.common.util.concurrent.ThreadFactoryBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.concurrent.*;

/**
 * @author Andya
 * @create 2020-05-29 14:08
 */
@Configuration
public class ThreadPoolConfig {

    public static String THREAD_NAME = "first-thread-pool-%d";
    public static final int CORE_POOL_SIZE = Runtime.getRuntime().availableProcessors() * 2 + 1;
    public static int MAX_POOL_SIZE = 10;
    public static int QUEUE_SIZE = 10;

    /**
     * 自定义消费队列线程池
     *
     * @return
     */
    @Bean(value = "firstThreadPool")
    public ExecutorService buildFirstThreadPool() {
        ThreadFactory threadFactory = new ThreadFactoryBuilder().setNameFormat(THREAD_NAME).build();

        /**
         * 1. CallerRunsPolicy ：    这个策略重试添加当前的任务，他会自动重复调用 execute() 方法，直到成功。
         2. AbortPolicy ：         对拒绝任务抛弃处理，并且抛出异常。
         3. DiscardPolicy ：       对拒绝任务直接无声抛弃，没有异常信息。
         4. DiscardOldestPolicy ： 对拒绝任务不抛弃，而是抛弃队列里面等待最久的一个线程，然后把拒绝任务加到队列。
         */
        ExecutorService threadPool = new ThreadPoolExecutor(
                CORE_POOL_SIZE,
                MAX_POOL_SIZE,
                0L,
                TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(QUEUE_SIZE),
                threadFactory,
                new ThreadPoolExecutor.AbortPolicy());
        return threadPool;
    }
}

定时任务模板

package com.example.andya.demo.service;

import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.TimeUnit;

/**
 * @author Andya
 * @create 2020-05-29 14:26
 */
@Service
@EnableScheduling
@Slf4j
public class TestThreadPool {
    @Resource(name = "firstThreadPool")
    private ExecutorService firstThreadPool;

    @Scheduled(cron = "0 * * * * *")
    public void test1SchedulerThreadPool() {
        final CountDownLatch countDownLatch = new CountDownLatch(5);
        log.info("Begin schedule-【1】 startTime: {}", new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
        for (int i = 0; i < 5; i++) {
            firstThreadPool.execute(() -> {
                countDownLatch.countDown();
                log.info("schedule-【1】 , threadPool info: {}, countDownLatch info: {}", firstThreadPool.toString(), countDownLatch.toString());
            });
        }
        try {
            countDownLatch.await(5, TimeUnit.MINUTES);
        } catch (InterruptedException e) {
            log.error("schedule-【1】timeout, {}", e.getMessage());
        } finally {
            log.info("schedule-【1】 multi-threading countDownLatch count: {}",  countDownLatch.getCount());
        }
        log.info("End schedule-【1】 startTime: {}", new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
    }

    @Scheduled(cron = "0 * * * * *")
    public void test2SchedulerThreadPool() {
        final CountDownLatch countDownLatch = new CountDownLatch(5);
        log.info("Begin schedule-【2】 startTime: {}", new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
        for (int i = 0; i < 5; i++) {
            firstThreadPool.execute(() -> {
                countDownLatch.countDown();
                log.info("schedule-【2】, threadPool info {}, countDownLatch info: {}", firstThreadPool.toString(), countDownLatch.toString());
            });
        }
        try {
            countDownLatch.await(5, TimeUnit.MINUTES);
        } catch (InterruptedException e) {
            log.error("schedule-【2】timeout, {}", e.getMessage());
        } finally {
            log.info("schedule-【2】 multi-threading countDownLatch count: {}",  countDownLatch.getCount());
        }
        log.info("End schedule-【2】 startTime: {}", new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
    }
}

运行结果

2020-05-29 15:45:00.011  INFO 6900 --- [pool-2-thread-1] c.e.andya.demo.service.TestThreadPool    : Begin schedule-【2】 startTime: 2020-05-29 15:45:00
2020-05-29 15:45:00.018  INFO 6900 --- [t-thread-pool-0] c.e.andya.demo.service.TestThreadPool    : schedule-【2】, threadPool info java.util.concurrent.ThreadPoolExecutor@26b894bd[Running, pool size = 5, active threads = 5, queued tasks = 0, completed tasks = 0], countDownLatch info: java.util.concurrent.CountDownLatch@522af59c[Count = 4]
2020-05-29 15:45:00.019  INFO 6900 --- [t-thread-pool-1] c.e.andya.demo.service.TestThreadPool    : schedule-【2】, threadPool info java.util.concurrent.ThreadPoolExecutor@26b894bd[Running, pool size = 5, active threads = 4, queued tasks = 0, completed tasks = 1], countDownLatch info: java.util.concurrent.CountDownLatch@522af59c[Count = 3]
2020-05-29 15:45:00.019  INFO 6900 --- [t-thread-pool-2] c.e.andya.demo.service.TestThreadPool    : schedule-【2】, threadPool info java.util.concurrent.ThreadPoolExecutor@26b894bd[Running, pool size = 5, active threads = 3, queued tasks = 0, completed tasks = 2], countDownLatch info: java.util.concurrent.CountDownLatch@522af59c[Count = 2]
2020-05-29 15:45:00.019  INFO 6900 --- [t-thread-pool-3] c.e.andya.demo.service.TestThreadPool    : schedule-【2】, threadPool info java.util.concurrent.ThreadPoolExecutor@26b894bd[Running, pool size = 5, active threads = 2, queued tasks = 0, completed tasks = 3], countDownLatch info: java.util.concurrent.CountDownLatch@522af59c[Count = 1]
2020-05-29 15:45:00.019  INFO 6900 --- [t-thread-pool-4] c.e.andya.demo.service.TestThreadPool    : schedule-【2】, threadPool info java.util.concurrent.ThreadPoolExecutor@26b894bd[Running, pool size = 5, active threads = 1, queued tasks = 0, completed tasks = 4], countDownLatch info: java.util.concurrent.CountDownLatch@522af59c[Count = 0]
2020-05-29 15:45:00.019  INFO 6900 --- [pool-2-thread-1] c.e.andya.demo.service.TestThreadPool    : schedule-【2】 multi-threading countDownLatch count: 0
2020-05-29 15:45:00.019  INFO 6900 --- [pool-2-thread-1] c.e.andya.demo.service.TestThreadPool    : End schedule-【2】 startTime: 2020-05-29 15:45:00
2020-05-29 15:45:00.020  INFO 6900 --- [pool-2-thread-1] c.e.andya.demo.service.TestThreadPool    : Begin schedule-【1】 startTime: 2020-05-29 15:45:00
2020-05-29 15:45:00.021  INFO 6900 --- [t-thread-pool-0] c.e.andya.demo.service.TestThreadPool    : schedule-【1】 , threadPool info: java.util.concurrent.ThreadPoolExecutor@26b894bd[Running, pool size = 9, active threads = 5, queued tasks = 0, completed tasks = 5], countDownLatch info: java.util.concurrent.CountDownLatch@5ced01a9[Count = 4]
2020-05-29 15:45:00.023  INFO 6900 --- [t-thread-pool-5] c.e.andya.demo.service.TestThreadPool    : schedule-【1】 , threadPool info: java.util.concurrent.ThreadPoolExecutor@26b894bd[Running, pool size = 9, active threads = 4, queued tasks = 0, completed tasks = 6], countDownLatch info: java.util.concurrent.CountDownLatch@5ced01a9[Count = 3]
2020-05-29 15:45:00.024  INFO 6900 --- [t-thread-pool-6] c.e.andya.demo.service.TestThreadPool    : schedule-【1】 , threadPool info: java.util.concurrent.ThreadPoolExecutor@26b894bd[Running, pool size = 9, active threads = 3, queued tasks = 0, completed tasks = 7], countDownLatch info: java.util.concurrent.CountDownLatch@5ced01a9[Count = 2]
2020-05-29 15:45:00.024  INFO 6900 --- [t-thread-pool-7] c.e.andya.demo.service.TestThreadPool    : schedule-【1】 , threadPool info: java.util.concurrent.ThreadPoolExecutor@26b894bd[Running, pool size = 9, active threads = 3, queued tasks = 0, completed tasks = 7], countDownLatch info: java.util.concurrent.CountDownLatch@5ced01a9[Count = 1]
2020-05-29 15:45:00.025  INFO 6900 --- [pool-2-thread-1] c.e.andya.demo.service.TestThreadPool    : schedule-【1】 multi-threading countDownLatch count: 0
2020-05-29 15:45:00.025  INFO 6900 --- [t-thread-pool-8] c.e.andya.demo.service.TestThreadPool    : schedule-【1】 , threadPool info: java.util.concurrent.ThreadPoolExecutor@26b894bd[Running, pool size = 9, active threads = 3, queued tasks = 0, completed tasks = 7], countDownLatch info: java.util.concurrent.CountDownLatch@5ced01a9[Count = 0]
2020-05-29 15:45:00.025  INFO 6900 --- [pool-2-thread-1] c.e.andya.demo.service.TestThreadPool    : End schedule-【1】 startTime: 2020-05-29 15:45:00

从上述结果中可以看出，虽然是test1SchedulerThreadPool()和test2SchedulerThreadPool()都是每分钟执行定时任务，但是明显两个方法没有并发执行，而是串行执行的。

并发定时器模板

通过增加一个配置类来并发执行定时任务。

package com.example.andya.demo.conf;

import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.SchedulingConfigurer;
import org.springframework.scheduling.config.ScheduledTaskRegistrar;

import java.util.concurrent.Executors;

/**
 * @author Andya
 * @create 2020-05-29 15:52
 */
@Configuration
public class ScheduleConfig implements SchedulingConfigurer {
    @Override
    public void configureTasks(ScheduledTaskRegistrar scheduledTaskRegistrar) {
        scheduledTaskRegistrar.setScheduler(Executors.newScheduledThreadPool(10));
    }
}

运行结果

2020-05-29 15:53:00.005  INFO 3028 --- [pool-2-thread-2] c.e.andya.demo.service.TestThreadPool    : Begin schedule-【2】 startTime: 2020-05-29 15:53:00
2020-05-29 15:53:00.015  INFO 3028 --- [pool-2-thread-1] c.e.andya.demo.service.TestThreadPool    : Begin schedule-【1】 startTime: 2020-05-29 15:53:00
2020-05-29 15:53:00.019  INFO 3028 --- [t-thread-pool-0] c.e.andya.demo.service.TestThreadPool    : schedule-【2】, threadPool info java.util.concurrent.ThreadPoolExecutor@5149f008[Running, pool size = 9, active threads = 9, queued tasks = 1, completed tasks = 0], countDownLatch info: java.util.concurrent.CountDownLatch@630f649f[Count = 3]
2020-05-29 15:53:00.020  INFO 3028 --- [t-thread-pool-3] c.e.andya.demo.service.TestThreadPool    : schedule-【2】, threadPool info java.util.concurrent.ThreadPoolExecutor@5149f008[Running, pool size = 9, active threads = 9, queued tasks = 1, completed tasks = 0], countDownLatch info: java.util.concurrent.CountDownLatch@630f649f[Count = 1]
2020-05-29 15:53:00.019  INFO 3028 --- [t-thread-pool-1] c.e.andya.demo.service.TestThreadPool    : schedule-【2】, threadPool info java.util.concurrent.ThreadPoolExecutor@5149f008[Running, pool size = 9, active threads = 9, queued tasks = 1, completed tasks = 0], countDownLatch info: java.util.concurrent.CountDownLatch@630f649f[Count = 3]
2020-05-29 15:53:00.019  INFO 3028 --- [t-thread-pool-2] c.e.andya.demo.service.TestThreadPool    : schedule-【2】, threadPool info java.util.concurrent.ThreadPoolExecutor@5149f008[Running, pool size = 9, active threads = 9, queued tasks = 1, completed tasks = 0], countDownLatch info: java.util.concurrent.CountDownLatch@630f649f[Count = 2]
2020-05-29 15:53:00.021  INFO 3028 --- [t-thread-pool-0] c.e.andya.demo.service.TestThreadPool    : schedule-【1】 , threadPool info: java.util.concurrent.ThreadPoolExecutor@5149f008[Running, pool size = 9, active threads = 6, queued tasks = 0, completed tasks = 4], countDownLatch info: java.util.concurrent.CountDownLatch@5ebb120e[Count = 4]
2020-05-29 15:53:00.021  INFO 3028 --- [t-thread-pool-4] c.e.andya.demo.service.TestThreadPool    : schedule-【2】, threadPool info java.util.concurrent.ThreadPoolExecutor@5149f008[Running, pool size = 9, active threads = 5, queued tasks = 0, completed tasks = 5], countDownLatch info: java.util.concurrent.CountDownLatch@630f649f[Count = 0]
2020-05-29 15:53:00.021  INFO 3028 --- [pool-2-thread-2] c.e.andya.demo.service.TestThreadPool    : schedule-【2】 multi-threading countDownLatch count: 0
2020-05-29 15:53:00.022  INFO 3028 --- [pool-2-thread-2] c.e.andya.demo.service.TestThreadPool    : End schedule-【2】 startTime: 2020-05-29 15:53:00
2020-05-29 15:53:00.022  INFO 3028 --- [t-thread-pool-5] c.e.andya.demo.service.TestThreadPool    : schedule-【1】 , threadPool info: java.util.concurrent.ThreadPoolExecutor@5149f008[Running, pool size = 9, active threads = 4, queued tasks = 0, completed tasks = 6], countDownLatch info: java.util.concurrent.CountDownLatch@5ebb120e[Count = 3]
2020-05-29 15:53:00.022  INFO 3028 --- [t-thread-pool-6] c.e.andya.demo.service.TestThreadPool    : schedule-【1】 , threadPool info: java.util.concurrent.ThreadPoolExecutor@5149f008[Running, pool size = 9, active threads = 3, queued tasks = 0, completed tasks = 7], countDownLatch info: java.util.concurrent.CountDownLatch@5ebb120e[Count = 2]
2020-05-29 15:53:00.024  INFO 3028 --- [t-thread-pool-7] c.e.andya.demo.service.TestThreadPool    : schedule-【1】 , threadPool info: java.util.concurrent.ThreadPoolExecutor@5149f008[Running, pool size = 9, active threads = 2, queued tasks = 0, completed tasks = 8], countDownLatch info: java.util.concurrent.CountDownLatch@5ebb120e[Count = 1]
2020-05-29 15:53:00.024  INFO 3028 --- [t-thread-pool-8] c.e.andya.demo.service.TestThreadPool    : schedule-【1】 , threadPool info: java.util.concurrent.ThreadPoolExecutor@5149f008[Running, pool size = 9, active threads = 2, queued tasks = 0, completed tasks = 8], countDownLatch info: java.util.concurrent.CountDownLatch@5ebb120e[Count = 0]
2020-05-29 15:53:00.024  INFO 3028 --- [pool-2-thread-1] c.e.andya.demo.service.TestThreadPool    : schedule-【1】 multi-threading countDownLatch count: 0
2020-05-29 15:53:00.024  INFO 3028 --- [pool-2-thread-1] c.e.andya.demo.service.TestThreadPool    : End schedule-【1】 startTime: 2020-05-29 15:53:00

可以从运行结果中看到，test1SchedulerThreadPool()和test2SchedulerThreadPool()两个方法同时打印了Begin schedule...信息，是并发定时。

@Async实现定时并发

除了上述这种实现SchedulingConfigurer类来实现定时任务的并发，还可以通过@EnableAsync及@Async注解实现定时任务的并发。

package com.example.andya.demo.util;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;

import java.time.LocalDateTime;

/**
 * @author Andya
 * @create 2020-04-20 22:50
 */
@Configuration
@EnableScheduling
@EnableAsync
public class StaticScheduleTask {

    private Logger LOG = LoggerFactory.getLogger(StaticScheduleTask.class);

    @Async
    @Scheduled(cron = "${schedule.cron}")
    public void firstTask() throws InterruptedException {
        for (int i = 0; i < 5; i++) {
            LOG.info("first task time： " + LocalDateTime.now() + "\r\nthread：" + Thread.currentThread().getName());
        }
        Thread.sleep(1000 * 10);
    }

    @Async
//    @Scheduled(fixedDelay = 5000)
    @Scheduled(cron = "0 * * * * *")
    public void secondTask() throws InterruptedException {
        for (int i = 0; i < 5; i++) {
            LOG.info("second task time： " + LocalDateTime.now() + "\r\nthread：" + Thread.currentThread().getName());
        }
        Thread.sleep(1000 * 10);
    }
}

运行结果：


2020-05-29 16:07:00.035  INFO 31428 --- [cTaskExecutor-1] c.e.andya.demo.util.StaticScheduleTask   : second task time： 2020-05-29T16:07:00.035
thread：SimpleAsyncTaskExecutor-1
2020-05-29 16:07:00.035  INFO 31428 --- [cTaskExecutor-2] c.e.andya.demo.util.StaticScheduleTask   : first task time： 2020-05-29T16:07:00.035
thread：SimpleAsyncTaskExecutor-2
2020-05-29 16:07:00.035  INFO 31428 --- [cTaskExecutor-1] c.e.andya.demo.util.StaticScheduleTask   : second task time： 2020-05-29T16:07:00.035
thread：SimpleAsyncTaskExecutor-1
2020-05-29 16:07:00.035  INFO 31428 --- [cTaskExecutor-2] c.e.andya.demo.util.StaticScheduleTask   : first task time： 2020-05-29T16:07:00.035
thread：SimpleAsyncTaskExecutor-2
2020-05-29 16:07:00.035  INFO 31428 --- [cTaskExecutor-1] c.e.andya.demo.util.StaticScheduleTask   : second task time： 2020-05-29T16:07:00.035
thread：SimpleAsyncTaskExecutor-1
2020-05-29 16:07:00.035  INFO 31428 --- [cTaskExecutor-2] c.e.andya.demo.util.StaticScheduleTask   : first task time： 2020-05-29T16:07:00.035
thread：SimpleAsyncTaskExecutor-2
2020-05-29 16:07:00.035  INFO 31428 --- [cTaskExecutor-1] c.e.andya.demo.util.StaticScheduleTask   : second task time： 2020-05-29T16:07:00.035
thread：SimpleAsyncTaskExecutor-1
2020-05-29 16:07:00.035  INFO 31428 --- [cTaskExecutor-2] c.e.andya.demo.util.StaticScheduleTask   : first task time： 2020-05-29T16:07:00.035
thread：SimpleAsyncTaskExecutor-2
2020-05-29 16:07:00.035  INFO 31428 --- [cTaskExecutor-1] c.e.andya.demo.util.StaticScheduleTask   : second task time： 2020-05-29T16:07:00.035
thread：SimpleAsyncTaskExecutor-1
2020-05-29 16:07:00.035  INFO 31428 --- [cTaskExecutor-2] c.e.andya.demo.util.StaticScheduleTask   : first task time： 2020-05-29T16:07:00.035
thread：SimpleAsyncTaskExecutor-2
Andya_net
关注
专栏目录
Spring Boot进阶(60)：5种判断线程池任务是否全部完成的方案 | 实用技巧分享！
**My Coding Family**
08-28 901
如何判断线程池任务是否全部执行完了？不会我手把手教你！
Java并发编程-AQS详解及案例实战（上篇）
program哲学
07-06 165
详细介绍AQS底层机制及相关应用案例实战
springboot 定时任务（线程配置，并行【同步】、异步等）
09-10
springboot 定时任务（线程配置，并行【同步】、异步等）
SpringBoot定时任务+自定义线程池
god-jiang的博客
01-12 3192
背景 在真实的Java开发环境中，我们经常会需要用到定时任务来帮助我们完成一些特殊的任务，比如我最近写的晚上11点定时拉取第三方的数据入库，晚上12点清理脏数据等等。 如果我们使用SpringBoot来开发，那么定时任务将会变得非常简单。SpringBoot默认已经帮我们封装好了相关定时任务的组件和配置，我们只需要在相应的地方加上@Schedule注解就可以实现定时任务。 启动定时任务 SpringBoot项目只需要在启动类上加上@EnableScheduling即可开启定时任务 @SpringBootAp
SpringBoot教程（二十一） | SpringBoot实现单点定时任务之@Scheduled
最新发布
qq_20236937的博客
08-14 1391
SpringBoot实现单点定时任务之@Scheduled
springboot 定时任务基础模板
Kingsley's Blog
12-22 592
springboot 定时任务，基础班，多线程版
spring boot定时任务(自定义类名字、方法名)线程池
wangrui2009ai的专栏
04-04 670
spring boot定时任务(自定义类名字、方法名)线程池
SpringBoot 多任务并行+线程池处理的实现
08-27
主要介绍了SpringBoot 多任务并行+线程池处理的实现,小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
springboot--配置线程池实现定时任务
wjianwei666的专栏
02-29 778
封装自定义线程池类是为了在线程执行完毕后，我们检查是否存在异常,如果存在异常，日志打印详细异常信息，这样可以可以帮助我们及时发现和解决问题。JDK 默认提供的定时调度线程池类是ScheduledThreadPoolExecutor，我们只需要继承它并重写它的 afterExecute 方法，添加异常日志打印的逻辑。@Override// 打印异常信息// 判断 r 是 Future 实例并且已经完成执行的情况下,获取它的执行结果，并检查是否有异常抛出>) {try {Future
SpringBoot项目给定时任务配置线程池
wl_Honest的博客
12-23 1566
上篇文章简单介绍了怎么在SpringBoot项目中运用简单的定时（间隔）任务，并且举例用的是单个任务，如果是多个定时（间隔）任务，并且想同时执行，应该怎么办？ 首先经过了解，@Scheduled是单线程的，如果有多个定时任务，势必需要前一个任务执行完才会执行后面的任务，先放代码： package com.wl.standard.task; import com.wl.standard.entity.City; import com.wl.standard.entity.CityGdp; import
Job Plus项目是基于SpringBoot+Vue的轻量级定时任务管理系统+源代码+文档说明
11-28
7. 强自定义：支持在线配置定时任务请求类型、请求路径、请求参数、Cron表达式，即时生效； 8. 动态控制：支持动态修改任务状态、启动/停止任务，以及终止运行中任务，即时生效； 9. 执行策略：支持丰富的执行策略，...
springboot2.0以上调度器配置线程池的实现
08-25
主要介绍了springboot2.0以上调度器配置线程池的实现，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Spring Boot中配置定时任务、线程池与多线程池执行的方法
08-25
主要给大家介绍了关于Spring Boot中配置定时任务、线程池与多线程池执行的相关资料，文中通过示例代码介绍的非常详细，对大家学习或者使用Spring Boot具有一定的参考学习价值，需要的朋友们下面来一起学习学习吧
Springboot&Springcloud面试题(含代码及展示图)
Java_Yhua的博客
12-02 848
1 简单说一下springboot? Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化Spring应用的初始搭建以及开发过程。 -使用springboot以后,搭建一个spring应用和开发，部署变得很简单. 2 怎么简单实现一个springboot应用 1）新建maven项目 2）让项目以spring-boot-starter-parent为父模块 <parent>     <group
SpringBoot
black210的博客
03-29 1069
1.了解 SpringBoot 人们把 Spring Boot称为搭建程序的脚手架。其最主要作用就是帮我们快速的构建庞大的spring项目，并且尽可能的减少一切xml配置，做到开箱即用，迅速上手，让我们关注于业务而非配置。 java一直被人诟病的一点就是臃肿、麻烦。当我们还在辛苦的搭建项目时，可能 Python程序员已经把功能写好了，究其原因主要是两点： 复杂的配置 项目各种配置其实是开发时的...
SpringBoot自定义线程池，执行定时任务
weixin_45341429的博客
09-16 1234
在我们开发过程中有很多场景需要定时执行，接下来我们在SpringBoot中实现定时任务的功能。因为springboot默认是提供单线程供我们使用，一旦有多个定时任务，当某个任务被阻塞，那么其他定时任务也不会被执行，所以，一般我们会自定义线程池来解决这个问题多个定时任务场景，某个阻塞情况演示@Service@Slf4j@Component@Autowired")@OverrideSystem.out.println("测试定时任务1------");
【自定义参数置线程池】SpringBoot 配自定义参数置线程池用于定时任务/异步任务等
wssf001的博客
06-05 944
使用场景1:定时任务使用线程池 在启动类上打上@EnableScheduling注解。使用场景2:异步任务使用线程池 在启动类上打上@EnableAsync注解。
spring boot自定义线程池
初心魏的博客
07-14 1085
一、自定义线程池 @Configuration @EnableAsync //可以异步执行，就是开启多线程的意思。 public class TaskExecutePool { @Autowired private TaskThreadPoolConfig config; @Bean public Executor myTaskAsyncPool(){ ...
Spring Boot定时任务详解（线程池方式）
热门推荐
嘉禾嘉宁papa
09-29 1万+
目录一、简介二、maven依赖三、核心配置3.1 配置文件application.yml3.2 属性配置3.3 配置自定义的TaskExecutor（重要）四、使用线程池实现定时任务五、运行结果六、参数设置（corePoolSize、queueCapacity、maxPoolSize）（重要）6.1 基本参数定义6.2 核心线程数（corePoolSize）6.3 任务队列数（queueCapacity）6.4 最大线程数（maxPoolSize）6.4.1 知识点一6.4.2 知识点二6.4.3 建议6.
springboot自定义线程池
04-04
在Spring Boot中，我们可以使用@Async注解来异步执行方法。但是默认情况下，Spring Boot使用的是SimpleAsyncTaskExecutor，它是一个单线程的线程池，不能满足高并发场景的需求。因此，我们需要自定义线程池来满足不同的需求。 下面是自定义线程池的步骤： 1. 创建自定义线程池的配置类 ```java @Configuration public class ThreadPoolConfig { @Bean("myThreadPool") public Executor myThreadPool(){ ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor(); // 线程池核心线程数 executor.setCorePoolSize(10); // 线程池最大线程数 executor.setMaxPoolSize(20); // 队列容量 executor.setQueueCapacity(100); // 线程池维护线程所允许的空闲时间 executor.setKeepAliveSeconds(60); // 线程池的前缀名 executor.setThreadNamePrefix("myThreadPool-"); // 拒绝策略，当线程池满了并且队列也满了，新任务会被拒绝 executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy()); // 初始化线程池 executor.initialize(); return executor; } } ``` 2. 在需要异步执行的方法上添加@Async注解，并指定使用的线程池 ```java @Service public class MyService { @Async("myThreadPool") public void asyncMethod(){ // 异步执行的方法体 } } ``` 3. 测试异步执行方法的效果 ```java @RestController public class MyController { @Autowired private MyService myService; @GetMapping("/async") public String async(){ myService.asyncMethod(); return "异步执行中..."; } } ``` 通过以上步骤，我们就可以自定义线程池来异步执行方法了。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值