springboot 定时任务@Scheduled 和 异步@Async

最新推荐文章于 2024-08-13 11:53:02 发布
最新推荐文章于 2024-08-13 11:53:02 发布
阅读量1.2k 收藏 6
点赞数
分类专栏： # java>spring 文章标签： springboot 定时任务 @Scheduled  异步@Async
原文链接：https://blog.csdn.net/tongyuyun123/article/details/83023008
版权

使用@EnableScheduling开启功能

@Configuration
@EnableScheduling
public class ScheduleConfig {
}

编写任务

@Component
public class ScheduledTasks {
     //表示上一次任务执行完成后多久再次执行，参数类型为long，单位ms;
     @Scheduled(fixedDelay = 500)
     public void fixedDelay(){
     }
     //表示按一定的频率执行任务，参数类型为long，单位ms;
     @Scheduled(fixedRate = 500)
     public void fixedRate(){
     }
     //cron表达式，指定任务在特定时间执行;
     @Scheduled(cron="0 50 * * * ?")
     public void cron(){
     }
     //第一次1秒后执行，当执行完后2秒再执行
     @Scheduled(initialDelay = 1000, fixedDelay = 2000)
     public void initialDelay() {
     }
     // 可以从配置文件中读取
     @Scheduled(fixedDelayString = "${jobs.fixedDelay}")
     public void fixedDelayString() {
     }
     /**
       * cron：cron表达式，指定任务在特定时间执行;
       * fixedDelay：表示上一次任务执行完成后多久再次执行，参数类型为long，单位ms;
       * fixedDelayString：与fixedDelay含义一样，只是参数类型变为String;
       * fixedRate：表示按一定的频率执行任务，参数类型为long，单位ms;
       * fixedRateString: 与fixedRate的含义一样，只是将参数类型变为String;
       * initialDelay：表示延迟多久再第一次执行任务，参数类型为long，单位ms;
       * initialDelayString：与initialDelay的含义一样，只是将参数类型变为String;
 	  */	
 }

配置（可选）

@Configuration
public class ScheduleConfig implements SchedulingConfigurer, AsyncConfigurer{
    //并行任务
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar){
        TaskScheduler taskScheduler = taskScheduler();
        taskRegistrar.setTaskScheduler(taskScheduler);
    }
    //并行任务使用策略：多线程处理（配置线程数等）
    @Bean
    public ThreadPoolTaskScheduler taskScheduler(){
        ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
        scheduler.setPoolSize(20);
        scheduler.setThreadNamePrefix("task-");  //设置线程名开头
        scheduler.setAwaitTerminationSeconds(60);
        scheduler.setWaitForTasksToCompleteOnShutdown(true);
        return scheduler;
    }
    //异步任务
    public Executor getAsyncExecutor(){
        Executor executor = taskScheduler();
        return executor;
    }
    //异步任务 异常处理
    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler(){
    	return new SimpleAsyncUncaughtExceptionHandler();
    }
}

定时任务线程池中，不管配置多少个线程，每次到定时点，只有一个线程去执行任务。假如配置fixedDelay=500，表示上一次任务执行完后，延迟500毫秒执行下次任务。如果任务执行需要500毫秒，那么任务的执行周期是500+500=1000毫秒。就算线程池中有多个线程，也会等那个任务执行完再选取一个线程再次执行任务。

@Bean("aaa")
public TaskScheduler  scheduler() {
    ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
    scheduler.setThreadNamePrefix("a");
    scheduler.setPoolSize(4);
    scheduler.initialize();
    return scheduler;
}
@Scheduled(fixedDelay = 500)
public void scheduled(){
    try {
        Thread.sleep(500);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    LOGGER.info(Thread.currentThread().getName());
}
2018-10-11 10:18:44.705     com.demo.test.async.ScheduleService      : a1
2018-10-11 10:18:45.710     com.demo.test.async.ScheduleService      : a1
2018-10-11 10:18:46.714     com.demo.test.async.ScheduleService      : a1
2018-10-11 10:18:47.715     com.demo.test.async.ScheduleService      : a1
2018-10-11 10:18:48.716     com.demo.test.async.ScheduleService      : a1
2018-10-11 10:18:49.719     com.demo.test.async.ScheduleService      : a1
2018-10-11 10:18:50.720     com.demo.test.async.ScheduleService      : a1
2018-10-11 10:18:51.722     com.demo.test.async.ScheduleService      : a1
2018-10-11 10:18:52.723     com.demo.test.async.ScheduleService      : a1
2018-10-11 10:18:53.724     com.demo.test.async.ScheduleService      : a1
2018-10-11 10:18:54.725     com.demo.test.async.ScheduleService      : a1
2018-10-11 10:18:55.726     com.demo.test.async.ScheduleService      : a3
2018-10-11 10:18:56.727     com.demo.test.async.ScheduleService      : a3
2018-10-11 10:18:57.729     com.demo.test.async.ScheduleService      : a3

加入配置fixedRate = 500，表示每500毫秒执行一次任务。如果任务执行时间大于配置的值，则任务执行完毕立即执行下一个任务。

@Bean("aaa")
public TaskScheduler  scheduler() {
    ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
    scheduler.setThreadNamePrefix("a");
    scheduler.setPoolSize(4);
    scheduler.initialize();
    return scheduler;
}
@Scheduled(fixedRate = 500)
public void scheduled(){
    LOGGER.info(Thread.currentThread().getName());
    try {
        Thread.sleep(2000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}
2018-10-11 11:01:21.218  com.demo.test.async.ScheduleService      :   a1
2018-10-11 11:01:23.219  com.demo.test.async.ScheduleService      :   a2
2018-10-11 11:01:25.220  com.demo.test.async.ScheduleService      :   a1
2018-10-11 11:01:27.221  com.demo.test.async.ScheduleService      :   a1
2018-10-11 11:01:29.221  com.demo.test.async.ScheduleService      :   a1
2018-10-11 11:01:31.222  com.demo.test.async.ScheduleService      :   a4
2018-10-11 11:01:33.223  com.demo.test.async.ScheduleService      :   a4

可以看到任务执行时间是2秒，大于配置500毫秒，所以任务执行完立即执行下一个任务。相当于执行周期变成了任务执行时间。

如果同时开启了@EnableAsync和使用了@Async，便变成了按配置时间(T)，每T执行一次任务。如果任务执行时间大于T，则会选取线程池中其他的线程去执行任务，如果没有剩余线程，则会等待有线程空闲出来。

@EnableAsync
@Configuration
public class ScheduleConfig implements SchedulingConfigurer {
    @Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
        taskRegistrar.setTaskScheduler( scheduler());
    }
    @Bean("aaa")
    public TaskScheduler   scheduler() {
        ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
        scheduler.setThreadNamePrefix("a");
        scheduler.setPoolSize(4);
        scheduler.initialize();
        return scheduler;
    }
}
 @Async("aaa")
@Scheduled(fixedRate = 500)
public void scheduled(){
    LOGGER.info(Thread.currentThread().getName());
    try {
        Thread.sleep(2000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}
2018-10-11 11:12:35.326  com.demo.test.async.ScheduleService      :  a4
2018-10-11 11:12:35.830  com.demo.test.async.ScheduleService      :  a2
2018-10-11 11:12:36.338  com.demo.test.async.ScheduleService      :  a1
2018-10-11 11:12:36.830  com.demo.test.async.ScheduleService      :  a3
2018-10-11 11:12:37.326  com.demo.test.async.ScheduleService      :  a4
2018-10-11 11:12:37.836  com.demo.test.async.ScheduleService      :  a2
2018-10-11 11:12:38.338  com.demo.test.async.ScheduleService      :  a1
2018-10-11 11:12:38.830  com.demo.test.async.ScheduleService      :  a3


使用@EnableScheduling，同时不使用@EnableAsync和taskRegistrar也没有添加线程池，这时候执行定时任务，会使用默认的线程池(只有一个线程),多个任务同步执行
@Configuration
@EnableScheduling
public class ScheduleConfig implements SchedulingConfigurer {
    @Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
    }
}
@Scheduled(fixedRate = 500)
public void scheduled(){
    LOGGER.info(Thread.currentThread().getName() + " -- aaa");
}
@Scheduled(fixedDelay = 1000)
public void fileProcessScheduled(){
    LOGGER.info(Thread.currentThread().getName() + " -- bbb");
}
2018-10-12 09:28:32.415  com.demo.test.async.ScheduleService      : pool-1-thread-1 -- aaa
2018-10-12 09:28:32.429  com.demo.test.async.ScheduleService      : pool-1-thread-1 -- bbb
2018-10-12 09:28:32.915  com.demo.test.async.ScheduleService      : pool-1-thread-1 -- aaa
2018-10-12 09:28:33.415  com.demo.test.async.ScheduleService      : pool-1-thread-1 -- aaa
2018-10-12 09:28:33.431  com.demo.test.async.ScheduleService      : pool-1-thread-1 -- bbb
2018-10-12 09:28:33.915  com.demo.test.async.ScheduleService      : pool-1-thread-1 -- aaa


使用@EnableScheduling，同时不使用@EnableAsync,然后在taskRegistrar添加指定线程池，这时候执行定时任务，会使用我们添加的线程池,多个任务同步执行
@Configuration
@EnableScheduling
public class ScheduleConfig implements SchedulingConfigurer {
    @Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
     	taskRegistrar.setTaskScheduler(scheduler());
    }
    @Bean
    public TaskScheduler scheduler() {
        ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
        scheduler.setThreadNamePrefix("a");
        scheduler.setPoolSize(3);
        scheduler.initialize();
        return scheduler;
    }
}
@Scheduled(fixedRate = 500)
public void scheduled(){
    LOGGER.info(Thread.currentThread().getName() + " -- aaa");
}
@Scheduled(fixedDelay = 1000)
public void fileProcessScheduled(){
    LOGGER.info(Thread.currentThread().getName() + " -- bbb");
}
2018-10-12 09:38:09.763   com.demo.test.async.ScheduleService      : a2 -- aaa
2018-10-12 09:38:10.265   com.demo.test.async.ScheduleService      : a2 -- aaa
2018-10-12 09:38:10.276   com.demo.test.async.ScheduleService      : a1 -- bbb
2018-10-12 09:38:10.764   com.demo.test.async.ScheduleService      : a3 -- aaa
2018-10-12 09:38:11.264   com.demo.test.async.ScheduleService      : a3 -- aaa
2018-10-12 09:38:11.276   com.demo.test.async.ScheduleService      : a2 -- bbb
2018-10-12 09:38:11.764   com.demo.test.async.ScheduleService      : a1 -- aaa


使用@EnableScheduling和@EnableAsync，然后在任务上用@Async("xxx")指定线程池，taskRegistrar添加不添加线程池无影响，会使用指定的，不会用registrar里添加的，这时候执行定时任务，会使用各自指定的线程池,多个任务（非一个线程池）并行执行
@EnableAsync
@Configuration
@EnableScheduling
public class ScheduleConfig implements SchedulingConfigurer {
    @Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
    }
    @Bean("aaa")
    public TaskScheduler   a() {
        ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
        scheduler.setThreadNamePrefix("a");
        scheduler.setPoolSize(3);
        scheduler.initialize();
        return scheduler;
    }
    @Bean("bbb")
    public TaskScheduler fileProcessScheduler() {
        ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
        scheduler.setThreadNamePrefix("b");
        scheduler.setPoolSize(2);
        scheduler.initialize();
        return scheduler;
    }
}
@Async("aaa")
@Scheduled(fixedRate = 500)
public void scheduled(){
     try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    LOGGER.info(Thread.currentThread().getName() + " -- aaa");
}
@Async("bbb")
@Scheduled(fixedDelay = 1000)
public void fileProcessScheduled(){
    LOGGER.info(Thread.currentThread().getName() + " -- bbb");
}
2018-10-12 09:43:54.484   com.demo.test.async.ScheduleService      : a2 -- aaa
2018-10-12 09:43:54.498   com.demo.test.async.ScheduleService      : b2 -- bbb
2018-10-12 09:43:54.985   com.demo.test.async.ScheduleService      : a3 -- aaa
2018-10-12 09:43:55.484   com.demo.test.async.ScheduleService      : a1 -- aaa
2018-10-12 09:43:55.498   com.demo.test.async.ScheduleService      : b1 -- bbb
2018-10-12 09:43:55.984   com.demo.test.async.ScheduleService      : a2 -- aaa
2018-10-12 09:43:56.485   com.demo.test.async.ScheduleService      : a3 -- aaa
2018-10-12 09:43:56.498   com.demo.test.async.ScheduleService      : b2 -- bbb
2018-10-12 09:43:56.984   com.demo.test.async.ScheduleService      : a1 -- aaa
和代码去流浪
关注
专栏目录
springboot 定时任务@Scheduled 和 异步@Async
阿拉斯加和他的猫
10-12 1万+
使用@EnableScheduling开启功能 @Configuration @EnableScheduling public class ScheduleConfig { } 编写任务 @Component public class ScheduledTasks { //表示上一次任务执行完成后多久再次执行，参数类型为long，单位ms; @Scheduled(...
springboot定时任务@Scheduled
四万八千里
12-15 812
1.多个任务单线程执行（默认） @Component @EnableScheduling // 开启定时任务，（这个注解用在启动类上的话，就不用每个task类都写一句@EnableScheduling public class Task { @Scheduled(cron = "0/60 * * * * ?")//60s执行一次 private void task1(){ System.out.println("定时任务一，恭喜发财~" + LocalDateTi
springboot @Scheduled和@Async
Coco_chun的博客
08-18 793
@Scheduled和@Async
@Scheduled异步执行-自定义线程池
最新发布
hbqst的博客
08-13 269
@Scheduled异步执行-自定义线程池
springboot @Scheduled实现定时任务，@EnableAsync，@Async异步任务
小哇
04-04 2411
实现定时任务的方式有如下几种，本文使用的是每3种 1、常见定时任务 Java自带的java.util.Timer类 timer:配置比较麻烦，时间延后问题 timertask:不推荐 2、Quartz框架 配置更简单 xml或者注解 3、SpringBoot使用注解方式开启定时任务 1）...
SpringBoot 定时任务Schedule，异步任务Async
chy1984的博客
09-20 1891
springboot的定时任务、异步任务都是使用单独的线程池，如果公司有线程池使用规范或觉得内置的线程池不满足需求，可以使用自定义的线程池。spring自带了定时任务、异步任务，springboot中自然也包含了进来，此处主要介绍在springboot中的使用。一个线程执行一个定时任务，如果线程数不够，会出现部分定时任务没有可用线程来执行的情况。定时任务、异步任务是spring|spring自带的，不需要额外添加依赖。通常会把定时|异步任务抽出来，统一放在单独的包、类中，方便维护。一共7个字段，依次是。
Spring Boot简单多线程定时任务实现 | @Async | @Scheduled
但行好事，莫问前程
12-25 568
Spring Boot简单多线程定时任务实现，demo笔记，快速上手！一文搞懂@Async和@Scheduled注解！
@scheduled任务调度使用详解及@scheduled与多线程和@Async异步任务结合使用
12-13
总结，`@Scheduled`任务调度是Spring Boot中实现定时任务的关键，它可以配合多线程和`@Async`异步任务提升程序的并发性能。通过自定义线程池和配置`TaskExecutor`，我们可以更好地控制任务的执行方式，从而优化应用...
SpringBoot使用注解@Scheduled（多线程定时任务）
一夕一绽一缕芳，一生一叹一痕沙
05-06 3061
最近做了一个定时任务的小工具，用到了注解@Scheduled，所以记录整理一下 1 SpringBoot集成Scheduled 1.1 添加maven依赖包 我这里是使用SpringBoot， Spring Scheduled已经包含在spring-boot-starter模块中 <dependencies> <dependency> <gro...
Java多线程之定时任务 以及 SpringBoot多线程实现定时任务——异步任务
03-12
1. SpringBoot 自定义线程池以及多线程间的异步调用（@Async、@EnableAsync） 2.Java多线程之定时任务 以及 SpringBoot多线程实现定时任务 3.@EnableScheduling 与 @Scheduled
springboot中@Scheduled 和@Async的使用
黄亚的博客
01-31 4173
如题，今天在知乎突然看到一份关于springboot自带调度器的问题思考，有这么一段内容“在使用@Scheduled注解时，如果不自己重新配置调度器，那么就会使用默认的，从而会导致一些调度执行上的问题”；联系到自己在程序中使用时没有关注到这个问题，因此仔细测试研究一番，最终了解了其中的一些关键思想。 首先，需要了解@Scheduled 和@Async这俩注解的区别： @Scheduled 任务调...
通过配置AsyncConfigurer来实现springboot的@Async异步调用异常捕获
老专家的博客
08-16 1万+
@Async 注解在service上，可以实现在controller的异步调用，调用的被@Async注解的方法会在一个单独线程内运行，适合即使返回，异步解耦，service慢慢去处理 @Async 注解的方法只能 返回void或者future类型的返回值，其他值会使 注解无效，因为不能异步执行 被@Async 的方法在独立线程调用，不能被@ControllerAdvice全局异常处理器捕获，所以需...
SpringBoot 线程池配置 实现AsyncConfigurer接口
热门推荐
qq_30281443的博客
10-24 1万+
线程是开发中常用到的，但是如果没有定义线程池，程序不断的创建，销毁线程，需要消耗很多时间，所以我们定义线程池可以减小这部分时间，我来实现AsyncConfigurer来配置线程池，先看看这个接口有什么方法 public interface AsyncConfigurer { Executor getAsyncExecutor(); AsyncUncaughtExceptionHand...
06 Spring 异步执行，任务调度（@Schedule、@Async）
赖赖的博客
12-14 9590
转载请注明来源 赖赖的博客导语 一个简单的抽象，可以解决百分之八十的问题。 在写Spring 应用的时候，会遇到一些异步执行和任务调度的问题，例如：Spring MVC中需要向微信发送请求，告诉微信进行公众号推送。这个时候需要用到异步执行，而周报表、月报表、日最高点击等，需要用到任务调度。 Spring高度凝聚了及其简单的调度和异步执行方式，迅速解决百分之八十的问题。 实例项目工程目录结构和代
@Scheduled任务调度/定时任务-非分布式
雾林小妖的博客
12-14 2178
springboot工程中使用@Scheduled实现任务调度和定时任务，及@Scheduled结合多线程和@Async异步任务的使用。
springboot的schedule任务配置
王静静的博客
04-10 741
任务类配置：package com.abc.schedule; import org.springframework.scheduling.annotation.Scheduled; import org.springframework.stereotype.Service; import java.text.SimpleDateFormat; import java.util.Date; ...
@Scheduled和@Async解析与自定义线程池
qq_39173672的博客
08-09 2749
@Scheduled和@Async注解解析与自定义线程池
Spring第38篇：定时器详解(@Scheduled & @EnableScheduling)
chenzoff的专栏
05-23 4629
Spring中@Scheduled & @EnableScheduling这2个注解，可以用来快速开发定时器，使用特别的简单。 如何使用？ 用法 1、需要定时执行的方法上加上@Scheduled注解，这个注解中可以指定定时执行的规则，稍后详细介绍。 2、Spring容器中使用@EnableScheduling开启定时任务的执行，此时spring容器才可以识别@Scheduled标注的方法，然后自动定时执行。 案例 db中有很多需要推送的任务，然后将其检索出来，推送到手机端，来个定时器..
springboot中 @Scheduled 和 @Async是用同一个线程池吗
04-29
不是。在Spring Boot中，@Scheduled和@Async是两种不同的机制，它们使用不同的线程池。 @Scheduled注解可以用于方法上，用来指定方法定时执行的时间。Spring Boot会使用一个名为“taskScheduler”的线程池来执行这些定时任务，默认情况下，这个线程池的大小为1。 而@Async注解用于异步方法上，用来指定方法在执行时是否应该在一个单独的线程中运行。Spring Boot会使用一个名为“async”的线程池来执行这些异步方法，默认情况下，这个线程池的大小为1。 因此，@Scheduled和@Async使用的是不同的线程池，它们之间没有关系。如果需要定时执行异步方法，可以考虑在@Scheduled方法中调用@Async方法来实现。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值