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

现在有关 springboot 的文章、书籍，真可谓是满天飞了，但是截至目前为止没有看到过一个有价值的，讲解的最多的是如何和各个的框架进行整合，现在 springboot 的出现就是为了简化框架的整合难度，而这些博文书籍大多讲解的都是这个，这里有一个 springboot 的博文的综合整理的连接：http://springboot.fun/，作者不是我，这里只是想举例，大家可以点进去看一看，看着名字狂拽炫酷吊炸天，点进去一看，每篇文章都是犹抱琵琶半遮面点到为止，也许作者是想体现朦胧美吧。还有很多博文除了标题，标点符号都是抄过来的，更有甚至测试都不测试，然后就把文章示例贴出来了……。真的需要静下心来写一点实用的东西，一些坑、一些技巧、一些设计心得、优化策略，不要总是停留在整合这个框架整合那个框架上面。

一、目录：

• 对比 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
public class 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

这里我是选用的quartz，因为我目前对于 springboot 的线程池的一些东西还不是很了解，所以目前先不入这个坑。目前来说这篇文章讲解的还是比较浅显，但是相比于讲配置的还是要高一点，后面还会继续的出一些高质量的博文，深入原理、数据结构、源码、设计来进行讲解，欢迎大家关注一下。

博客首发地址csdn：https://blog.csdn.net/weixin_42849915
简书地址：https://www.jianshu.com/u/4b48be4cf59f
希望结识更多的大牛一同学习一同进步