spring boot schedule VS quartz

2020-06-01 本文已影响0人不怕天黑_0819

前言

项目中涉及到spring boot定时任务执行，发现有2种方式，schedule和quartz，所以萌生了详细了解两种定时方式的区别，这样在使用时，才能做到不留坑，不踩坑。
本文主要从2个方面介绍。首先是介绍如何使用，其次是2者的区别。

1. schedule的使用

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

@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());
   }
}

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

分析执行结果

我是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 注解）
使用多线程

@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 也发生了并行执行了。由此可能引发的数据的不一致

使用线程池的方法

配置线程池：


@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发生异常的情况下，再次触发的时候，是不会执行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());
    }

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

2.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 的单任务串行执行，多任务并行执行的关键

关于cron表达式的使用，可以参考 cron表达式
关于springboot quartz 的持久化，本文暂时不做讲解。