springboot的schedule和quartz到底怎么选以及如何支持并发和避坑

最新推荐文章于 2024-07-10 09:10:32 发布

小小学徒ByronZf

最新推荐文章于 2024-07-10 09:10:32 发布

阅读量1w

点赞数 24

分类专栏： Spring

Spring 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

一、目录：

对比 schedule 和 quartz 两者的不同
schedule 如何调整对于并发的支持，以及坑
破解网上传言 scheduled 发生异常不在执行
quartz 如何应对并发

二、scheduled 和 quartz 的对比

这里只谈单机版的，不说分布式的，在分布式中有其他的框架可以解决，同时quartz也是可以支持分布式的。

组件名称	cron	持久化	开发难以程度
schedule	支持	不支持	非常简单
quartz	支持	支持	复杂

三、schedule的使用，以及几个注解的简单的测试讲解：

##３.１使用步骤

1、首先需要在启动类上添加 @EnableScheduling 的注解
2、开发task

3.2 简单例子：

上面我在说难以程度上面，说 schedule 非常的简单，下面举例：

@Component
@Slf4j
public class SbScheduleTask1 {
    @Scheduled(cron = "*/2 * * * * ?")
    public void task1() throws InterruptedException {
        log.error("我是task1111，我需要执行 10s 钟的时间，我的线程的 id == > {}，时间 == >{}", Thread.currentThread().getId(), new Date());
        Thread.sleep(10000);
        log.error("task1111 ending ,我的线程的 id == > {} , 时间 == > {}", Thread.currentThread().getId(), new Date());    
    } 
   
    @Scheduled(cron = "*/4 * * * * ?")    
    public void task2() throws InterruptedException {
        log.error("我是task2222，我需要执行 2s 钟的时间，我的线程的 id == > {}，时间 == >{}", Thread.currentThread().getId(), new Date());
        Thread.sleep(2000);
        log.error("task2222 ending ,我的线程的 id == > {} , 时间 == > {}",Thread.currentThread().getId(), new Date());
   }
}

是的就是这么简单，就这样就可以实现两个定时任务了。

3.2.1 注解 scheduled 的参数讲解：

去掉注释后的源码：

public @interface Scheduled {
    String CRON_DISABLED = "-";
    String cron() default "";
    String zone() default "";
    long fixedDelay() default -1;
    String fixedDelayString() default "";
    long fixedRate() default -1;
    String fixedRateString() default "";
    long initialDelay() default -1;
    String initialDelayString() default "";
}

cron ：来源于linux，注释是描述任务执行触发的方式的
zone：描述时区，因为不同的地方时区不一致
fixedDelay：固定间隔，假设任务从 0s 开始执行，10s 执行一次，但是任务执行了12s 那么下次的执行时间就是 22s，即：就是两次任务的固定的间隔
fixedRate：固定的频率，假设任务从 0s 执行，10s 执行一次，但是任务执行12s，那么下次执行的时间是 12s

3.2.2 我们来分析一下执行的结果：

我是task1111，我需要执行 10s 钟的时间，我的线程的 id == > 95，时间 == >Fri Feb 01 15:16:52 CST 2019
task1111 ending ,我的线程的 id == > 95 , 时间 == > Fri Feb 01 15:17:02 CST 2019
我是task2222，我需要执行 2s 钟的时间，我的线程的 id == > 95，时间 == >Fri Feb 01 15:17:02 CST 2019
task2222 ending ,我的线程的 id == > 95 , 时间 == > Fri Feb 01 15:17:04 CST 2019
我是task1111，我需要执行 10s 钟的时间，我的线程的 id == > 95，时间 == >Fri Feb 01 15:17:04 CST 2019
task1111 ending ,我的线程的 id == > 95 , 时间 == > Fri Feb 01 15:17:14 CST 2019

大家可以看到，线程 id 都是一致的，也就是说默认的情况下，schedule是默认一单线程的情况执行的。同时从执行的时间上我们也可以看出。但是我们想要的是这两个任务并发执行呀，如何解决呢：

使用 @Async 注解来实现（启动类上要添加：@EnableAsync 注解）
使用多线程

3.2.3 我们先来使用 @Async 来实现以下看结果

@Component
@Slf4j
public class SbScheduleTask1 {
    @Async
    @Scheduled(cron = "*/2 * * * * ?")
    public void task1() throws InterruptedException {
        log.error("我是task1111，我需要执行 10s 钟的时间，我的线程的 id == > {}，时间 == >{}", Thread.currentThread().getId(), new Date());
        Thread.sleep(10000);
        log.error("task1111 ending ,我的线程的 id == > {} , 时间 == > {}", Thread.currentThread().getId(), new Date());
    }
    @Async
    @Scheduled(cron = "*/4 * * * * ?")
    public void task2() throws InterruptedException {
        log.error("我是task2222，我需要执行 2s 钟的时间，我的线程的 id == > {}，时间 == >{}", Thread.currentThread().getId(), new Date());
        Thread.sleep(2000);
        log.error("task2222 ending ,我的线程的 id == > {} , 时间 == > {}", Thread.currentThread().getId(), new Date());
    }
}

日志结果：

我是task2222，我需要执行 2s 钟的时间，我的线程的 id == > 116，时间 == >Fri Feb 01 16:19:32 CST 2019
我是task1111，我需要执行 10s 钟的时间，我的线程的 id == > 117，时间 == >Fri Feb 01 16:19:32 CST 2019
我是task1111，我需要执行 10s 钟的时间，我的线程的 id == > 124，时间 == >Fri Feb 01 16:19:34 CST 2019
task2222 ending ,我的线程的 id == > 116 , 时间 == > Fri Feb 01 16:19:34 CST 2019
我是task1111，我需要执行 10s 钟的时间，我的线程的 id == > 125，时间 == >Fri Feb 01 16:19:36 CST 2019
我是task2222，我需要执行 2s 钟的时间，我的线程的 id == > 126，时间 == >Fri Feb 01 16:19:36 CST 2019
我是task1111，我需要执行 10s 钟的时间，我的线程的 id == > 127，时间 == >Fri Feb 01 16:19:38 CST 2019
task2222 ending ,我的线程的 id == > 126 , 时间 == > Fri Feb 01 16:19:38 CST 2019
我是task2222，我需要执行 2s 钟的时间，我的线程的 id == > 128，时间 == >Fri Feb 01 16:19:40 CST 2019
我是task1111，我需要执行 10s 钟的时间，我的线程的 id == > 129，时间 == >Fri Feb 01 16:19:40 CST 2019

分析上述的日志可知：task1 和 task2 的确是并行执行的，因为开始的时间节点是一样的

但是我们刚解决一个坑，另外一个坑也来。我们细心观察可以发现 task1 也发生了并行执行了。由此引发的数据的不一致，事务的问题这是我们无法接受的。

3.2.4 下面我们使用线程池的方

配置线程池：

@Configuration
@Slf4j
publicclass ScheduleConfig implements SchedulingConfigurer {
    @Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
        taskRegistrar.setScheduler(taskExecutor());    
    }
    @Bean
    public Executor taskExecutor(){
        return Executors.newScheduledThreadPool(10);
    }
}

具体的任务类：

@Component
@Slf4j
public class SbScheduleTask1 {

//    @Async
    @Scheduled(cron = "*/2 * * * * ?")
    public void task1() throws InterruptedException {
        log.error("我是task1111，我需要执行 10s 钟的时间，我的线程的 id == > {}，时间 == >{}", Thread.currentThread().getId(), new Date());
        Thread.sleep(10000);
        log.error("task1111 ending ,我的线程的 id == > {} , 时间 == > {}", Thread.currentThread().getId(), new Date());
    }

//    @Async
    @Scheduled(cron = "*/4 * * * * ?")
    public void task2() throws InterruptedException {
        log.error("我是task2222，我需要执行 2s 钟的时间，我的线程的 id == > {}，时间 == >{}", Thread.currentThread().getId(), new Date());
        Thread.sleep(2000);
        log.error("task2222 ending ,我的线程的 id == > {} , 时间 == > {}", Thread.currentThread().getId(), new Date());
    }
}

执行的结果

我是task2222，我需要执行 2s 钟的时间，我的线程的 id == > 95，时间 == >Fri Feb 01 16:28:16 CST 2019
我是task1111，我需要执行 10s 钟的时间，我的线程的 id == > 96，时间 == >Fri Feb 01 16:28:16 CST 2019
task2222 ending ,我的线程的 id == > 95 , 时间 == > Fri Feb 01 16:28:18 CST 2019
我是task2222，我需要执行 2s 钟的时间，我的线程的 id == > 95，时间 == >Fri Feb 01 16:28:20 CST 2019
task2222 ending ,我的线程的 id == > 95 , 时间 == > Fri Feb 01 16:28:22 CST 2019
我是task2222，我需要执行 2s 钟的时间，我的线程的 id == > 121，时间 == >Fri Feb 01 16:28:24 CST 2019
task1111 ending ,我的线程的 id == > 96 , 时间 == > Fri Feb 01 16:28:26 CST 2019
task2222 ending ,我的线程的 id == > 121 , 时间 == > Fri Feb 01 16:28:26 CST 2019
我是task1111，我需要执行 10s 钟的时间，我的线程的 id == > 95，时间 == >Fri Feb 01 16:28:28 CST 2019
我是task2222，我需要执行 2s 钟的时间，我的线程的 id == > 122，时间 == >Fri Feb 01 16:28:28 CST 2019

我们分析可知：两个任务是并行执行的，但是单个任务还是串行（可能这样描述并不太准备）的在执行的，这样完全是满足我们的要求的。基本上关于schedule的部分差不多讲完了。

3.2.4 小tips：

需求描述：要在每月的最后一天统计收益率，只能是每月的最后一天，因为晚上有夜市交易，会对这个产生影响
但是 springboot 的 schedule 并不支持带有字母的表达式，但是我们可以采用一种变通的方式
cron = “0 0 0 28,29,30,31 * ?” 因为月末只能是 28|29|30|31这几天，所以我们在加上一个判断就好了

四、现在我们来破除网上传言：

据网上谣传：当schedule发生异常的情况下，再次出发的时候，是不会执行task的，那么下面我们就试一试：

  @Scheduled(cron = "*/4 * * * * ?")
    public void task2() throws InterruptedException {
        log.error("我是task2222，我需要执行 2s 钟的时间，我的线程的 id == > {}，时间 == >{}", Thread.currentThread().getId(), new Date());
        Thread.sleep(2000);
        int i = 1/0;
        log.error("task2222 ending ,我的线程的 id == > {} , 时间 == > {}", Thread.currentThread().getId(), new Date());
    }

很明显的我们可以看到，即使报错了，但是任务还是可以一直执行的。

四 springboot 2.0 整合quartz，以及并发的支持：

这里我们使用的是简化的 spring-boot-starter-quartz 这个可以配置的到简化，所以这里强调一下版本。

引入pom

  <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-quartz</artifactId>
  </dependency>

配置类：

@Configuration
public class ScheduleConfig1 {
    protected static final Level OPERATING = Level.forName("BUS", 250);
    private static final Logger log = LogManager.getLogger();


    @Bean

    public JobDetail task1JobDetail() {
        return JobBuilder.newJob(Task1.class)
                .withIdentity("task1")
                .storeDurably(true)
                .build();
    }

    @Bean
    public JobDetail task2JobDetail() {
        return JobBuilder.newJob(Task2.class)
                .withIdentity("task2")
                .storeDurably(true)
                .build();
    }

    @Bean
    public Trigger task1Trigger() {
        CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule("*/4 * * * * ?");
        return TriggerBuilder.newTrigger()
                .forJob(task1JobDetail())
                .withIdentity("task1")
                .withSchedule(scheduleBuilder)
                .build();
    }

    @Bean
    public Trigger task2Trigger() {
        CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule("*/4 * * * * ?");
        return TriggerBuilder.newTrigger()
                .forJob(task2JobDetail())
                .withIdentity("task2")
                .withSchedule(scheduleBuilder)
                .build();
    }
}

task1

@Slf4j
@Component
@DisallowConcurrentExecution
public class Task1 extends QuartzJobBean {
    @Override
    protected void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        log.error("我是task1111 ，我将执行10s钟， 线程名字 == > {} , 现在时间为 == > {}", Thread.currentThread().getId(),new Date());
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        log.error("我是task1111，我已经执行完成了，线程名字 == > {} , 现在时间为 == > {}",Thread.currentThread().getId(),new Date());
    }
}

task2

@Component
@DisallowConcurrentExecution
public class Task2 extends QuartzJobBean {

    @Override
    protected void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        log.error("我是task2222 ，我将执行2s钟， 线程名字 == > {} , 现在时间为 == > {}", Thread.currentThread().getId(),new Date());
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getId());
        log.error("我是task2222，我已经执行完成了，线程名字 == > {} , 现在时间为 == > {}",Thread.currentThread().getId(),new Date());
    }
}

下面看执行的结果

我是task2222 ，我将执行2s钟，线程名字 == > 82 , 现在时间为 == > Fri Feb 01 17:15:16 CST 2019
我是task1111 ，我将执行10s钟，线程名字 == > 81 , 现在时间为 == > Fri Feb 01 17:15:16 CST 2019
我是task2222，我已经执行完成了，线程名字 == > 82 , 现在时间为 == > Fri Feb 01 17:15:18 CST 2019
我是task2222 ，我将执行2s钟，线程名字 == > 83 , 现在时间为 == > Fri Feb 01 17:15:20 CST 2019
我是task2222，我已经执行完成了，线程名字 == > 83 , 现在时间为 == > Fri Feb 01 17:15:22 CST 2019
我是task2222 ，我将执行2s钟，线程名字 == > 84 , 现在时间为 == > Fri Feb 01 17:15:24 CST 2019
我是task2222，我已经执行完成了，线程名字 == > 84 , 现在时间为 == > Fri Feb 01 17:15:26 CST 2019
我是task1111，我已经执行完成了，线程名字 == > 81 , 现在时间为 == > Fri Feb 01 17:15:26 CST 2019
我是task1111 ，我将执行10s钟，线程名字 == > 85 , 现在时间为 == > Fri Feb 01 17:15:26 CST 2019
我是task2222 ，我将执行2s钟，线程名字 == > 86 , 现在时间为 == > Fri Feb 01 17:15:28 CST 2019

可以看到这个是和我们使用线程池的效果是一样的，但是请注意：@DisallowConcurrentExecution这个注解是使得 quartz 的单任务串行执行，多任务并行执行的关键

五、总结：

我们可以看到使用schedule是非常的简洁的，少量的配置即可，但是如果使用quartz的话就需要配置很多的东西，如果定时任务需要设计的很复杂，需要应为例如：上班时间这样的匹配规则的话，以及我们需要动态的设置定时任务以及需要持久化定时任务的话，我们就最好是使用quartz。

小小学徒ByronZf

关注

24
点赞
踩
59

收藏

觉得还不错? 一键收藏
9
评论
springboot的schedule和quartz到底怎么选以及如何支持并发和避坑

一、目录：对比 schedule 和 quartz 两者的不同 schedule 如何调整对于并发的支持，以及坑破解网上传言 scheduled 发生异常不在执行 quartz 如何应对并发二、scheduled 和 quartz 的对比这里只谈单机版的，不说分布式的，在分布式中有其他的框架可以解决，同时quartz也是可以支持分布式的。组件名称 cron ...
复制链接

扫一扫

专栏目录