1. 定时任务调度概述

1.1 业务场景概述

日常开发中定时任务使用场景很多，比如支付系统每天凌晨定时清算对账；未支付订单超时回收；商品定时上下架等等。定时任务框架选择有很多，面对不同的业务场景可以选择不同的定时任务框架，比如操作系统自带的定时任务Linux的crontab，Windows的任务计划等，在某些相对简单的场景下也是可以使用的，这里就不在详细探讨，本文主要讲述Java框架下的定时任务框架。

1.2 任务调度场景

时间驱动/事件驱动：内部系统一般可以通过时间来驱动，但涉及到外部系统，则只能使用时间驱动。如怕取外部网站价格，每小时爬一次。

批量处理/逐条处理：批量处理堆积的数据更加高效，在不需要实时性的情况下比消息中间件更有优势。而且有的业务逻辑只能批量处理。如移动每个月结算我们的话费。

实时性/非实时性：消息中间件能够做到实时处理数据，但是有些情况下并不需要实时，比如：vip升级。

系统内部/系统解耦：定时任务调度一般是在系统内部，而消息中间件可用于两个系统间。

1.3 调度任务分类

1.单机定时任务
timer：是一个定时器类，通过该类可以为指定的定时任务进行配置。TimerTask类是一个定时任务类，该类实现了Runnable接口，缺点异常未检查会中止线程。

ScheduledExecutorService：相对延迟或者周期作为定时任务调度，缺点没有绝对的日期或者时间。

springTask：配置简单功能较多，如果系统使用单机的话可以优先考虑spring定时器。

2.分布式定时任务
Quartz：Java事实上的定时任务标准。但Quartz关注点在于定时任务而非数据，并无一套根据数据处理而定制化的流程。虽然Quartz可以基于数据库实现作业的高可用，但缺少分布式并行调度的功能。
Quartz官方网址：http://www.quartz-scheduler.org/
Quartz官方文档：http://www.quartz-scheduler.org/documentation/
Quartz原码地址：https://github.com/quartz-scheduler/quartz

xxl-job：是大众点评员工徐雪里于2015年发布的分布式任务调度平台，是一个轻量级分布式任务调度框架，其核心设计目标是开发迅速、学习简单、轻量级、易扩展。产品功能丰富，开箱即用。
xxl-job 社区地址： https://www.xuxueli.com/xxl-job/
xxl-job github地址：https://github.com/xuxueli/xxl-job/
xxl-job gitee地址： https://gitee.com/xuxueli0323/xxl-job

elastic-job：当当开源的弹性分布式任务调度系统，目前赠送给Apache开源基金会。
ElasticJob 是一个分布式调度解决方案，由 2 个相互独立的子项目 ElasticJob-Lite 和 ElasticJob-Cloud 组成。
ElasticJob-Lite 定位为轻量级无中心化解决方案，使用jar的形式提供分布式任务的协调服务；
ElasticJob-Cloud 使用 Mesos 的解决方案，额外提供资源治理、应用分发以及进程隔离等服务。
ElasticJob 的各个产品使用统一的作业 API，开发者仅需要一次开发，即可随意部署。
elastic-job文档地址：https://shardingsphere.apache.org/elasticjob/index_zh.html

SchedulerX：分布式任务调度SchedulerX是阿里巴巴自研的基于Akka架构的分布式任务调度平台，兼容开源XXL-JOB、ElasticJob，支持Cron定时、一次性任务、任务编排、分布式执行批量任务等功能，具备高可用、可视化、可运维、低延时等能力。
SchedulerX文档地址：https://help.aliyun.com/document_detail/148185.html

Saturn：Saturn (任务调度系统)是唯品会开源的一个分布式任务调度平台，取代传统的Linux Cron/Spring Batch Job的方式，做到全域统一配置，统一监控，任务高可用以及分片并发处理。Saturn是在当当开源的Elastic Job基础上，结合各方需求和我们的实践见解改良而成。
Saturn gitee文档地址：https://gitee.com/vipshop/Saturn?utm_source=alading&utm_campaign=repo
Saturn github文档地址：https://github.com/vipshop/Saturn

2. 定时任务调度详解

2.1 Timer

Timer类是jdk专门提供的定时器工具，用来在后台线程计划执行指定任务，在java.util包下，要跟TimerTask一起配合使用。TimerTask单机单线程加锁阻塞执行的，Timer类其实是一个任务调度器，它里面包含了一个TimerThread线程，在这个线程中无限循环从TaskQueue中获取TimerTask（该类实现了Runnable接口），调用其run方法，就能异步执行定时任务。我们需要继承TimerTask类，实现它的run方法，在该方法中加上自己的业务逻辑。

使用方式
先实例化一个Timer类，然后调用它的schedule方法，在该方法中实例化TimerTask类，业务逻辑写在run方法中。schedule方法最后的两次参数分别表示：延迟时间 和 间隔时间，单位是毫秒。上面例子中，设置的定时任务是每隔1秒执行一次，延迟2秒执行。

主要方法
schedule(TimerTask task, Date time), 指定任务task在指定时间time执行
schedule(TimerTask task, long delay), 指定任务task在指定延迟delay后执行
schedule(TimerTask task, Date firstTime,long period),指定任务task在指定时间firstTime执行后，进行重复固定延迟频率peroid的执行
schedule(TimerTask task, long delay, long period), 指定任务task 在指定延迟delay 后，进行重复固定延迟频率peroid的执行
scheduleAtFixedRate(TimerTask task,Date firstTime,long period), 指定任务task在指定时间firstTime执行后，进行重复固定延迟频率peroid的执行
scheduleAtFixedRate(TimerTask task, long delay, long period), 指定任务task 在指定延迟delay 后，进行重复固定延迟频率peroid的执行

存在问题
1.由于Timer是单线程执行任务，如果其中一个任务耗时非常长，会影响其他任务的执行。
2.如果TimerTask抛出RuntimeException，Timer会停止所有任务的运行。

优缺点
优点：非常方便实现多个周期性的定时任务，并且支持延迟执行，还支持在指定时间之后支持，功能还算强大。

缺点：如果其中一个任务耗时非常长，会影响其他任务的执行。并且如果TimerTask抛出RuntimeException，Timer会停止所有任务的运行，所以阿里巴巴开发者规范中不建议使用它。

操作验证

    /**
     * TimerTask
     */
    private void timerTaskTest() {
        java.util.TimerTask timerTask = new java.util.TimerTask() {
            @Override
            public void run() {
                System.out.println("【JavaTask】"+Thread.currentThread().getName() + "，TimerTask，" + DateUtil.date());
            }
        };
        Timer timer = new Timer();
        timer.schedule(timerTask, 10, 3000);
    }

2.2 ScheduledExecutorService

ScheduledExecutorService是JDK1.5+版本引进的定时任务，该类位于java.util.concurrent并发包下。相当于多线程版本的Timer，ScheduledExecutorService是基于多线程的，设计的初衷是为了解决Timer单线程执行，多个任务之间会互相影响的问题。

主要方法
schedule(Runnable command,long delay,TimeUnit unit)，带延迟时间的调度，只执行一次，调度之后可通过Future.get()阻塞直至任务执行完毕。
schedule(Callable callable,long delay,TimeUnit unit)，带延迟时间的调度，只执行一次，调度之后可通过Future.get()阻塞直至任务执行完毕，并且可以获取执行结果。
scheduleAtFixedRate，表示以固定频率执行的任务，如果当前任务耗时较多，超过定时周期period，则当前任务结束后会立即执行。
scheduleWithFixedDelay，表示以固定延时执行任务，延时是相对当前任务结束为起点计算开始时间。

使用方式
调用ScheduledExecutorService类的scheduleAtFixedRate方法实现周期性任务，每隔1秒钟执行一次，每次延迟1秒再执行。这种定时任务是阿里巴巴开发者规范中用来替代Timer类的方案，对于多线程执行周期性任务，是个不错的选择。

优缺点
优点：基于多线程的定时任务，多个任务之间不会相关影响，支持周期性的执行任务，并且带延迟功能。
缺点：不支持一些较复杂的定时规则。

操作验证

    /**
     * ScheduledExecutorService
     */
    private void ScheduledExecutorTest() {
        //为了方便测试这里使用线程池工具创建线程池，建议手动创建线程池，避免内存溢出
        ScheduledExecutorService ses = Executors.newScheduledThreadPool(5);

        //按照固定频率执行，每隔5秒跑一次
        ses.scheduleAtFixedRate(() -> System.out.println("【JavaTask】ScheduledExecutorService-1，" + DateUtil.date()), 0, 5, TimeUnit.SECONDS);

        //按照固定延时执行，上次执行完后隔3秒再跑
        ses.scheduleWithFixedDelay(() -> System.out.println("【JavaTask】ScheduledExecutorService-2，" + DateUtil.date()), 0, 3, TimeUnit.SECONDS);
    }

2.3 SpringTask

spring task是spring3以上版本自带的定时任务，实现定时任务的功能时，需要引入spring-context包，目前它支持：xml 和 注解 两种方式。由于xml方式太古老了，我们以springboot项目中注解方式为例。

主要方法
@EnableScheduling 开启调度
@Scheduled(cron = “10 * * * * ?”) cron 表达式
@Scheduled(fixedRate = 5000) 循环调用
@Scheduled(fixedDelay = 3000) 循环延迟调用

cron规则
spring4以上的版本中，cron表达式包含6个参数：[秒] [分] [时] [日期] [月] [星期]

支持几个常用的特殊符号：
    *：表示任何时间触发任务
    ,：表示指定的时间触发任务
    -：表示一段时间内触发任务
    /：表示从哪一个时刻开始，每隔多长时间触发一次任务。
    ?：表示用于月中的天和周中的天两个子表达式，表示不指定值。

cron表达式参数具体含义：
    秒，取值范围：0-59，支持*、,、-、/。
    分，取值范围：0-59，支持*、,、-、/。
    时，取值范围：0-23，支持*、,、-、/。
    日期，取值范围：1-31，支持*、,、-、/。比秒多了?，表示如果指定的星期触发了，则配置的日期变成无效。
    月，取值范围：1-12，支持*、,、-、/。
    星期，取值范围：1~7，1代表星期天，6代表星期六，其他的以此类推。支持*、,、-、/、?。比秒多了?，表示如果指定的日期触发了，则配置的星期变成无效。

常见cron表达式使用举例：
    0 0 0 1 * ?  每月1号零点执行
    0 0 2 * * ?  每天凌晨2点执行
    0 0 2 * * ?  每天凌晨2点执行
    0 0/5 11 * * ? 每天11点-11点55分，每隔5分钟执行一次
    0 0 18 ? * WED 每周三下午6点执行

使用方式
spring task先通过ScheduledAnnotationBeanPostProcessor类的processScheduled方法，解析和收集Scheduled注解中的参数，包含：cron表达式。然后在ScheduledTaskRegistrar类的afterPropertiesSet方法中，默认初始化一个单线程的ThreadPoolExecutor执行任务。

优缺点
优点：spring框架自带的定时功能，springboot做了非常好的封装，开启和定义定时任务非常容易，支持复杂的cron表达式，可以满足绝大多数单机版的业务场景。单个任务时，当前次的调度完成后，再执行下一次任务调度。
缺点：默认单线程，如果前面的任务执行时间太长，对后面任务的执行有影响。不支持集群方式部署，不能做数据存储型定时任务。

操作验证

package com.zrj.flowable.job;

import cn.hutool.core.date.DateUtil;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

/**
 * SpringTask
 * 项目启动，定时任务同时启动开始运行
 *
 * @author zrj
 * @since 2022/4/13
 **/
@Component
@EnableScheduling
public class ScheduledSpringTask {

    /**
     * 每分钟的第10秒跑一次
     * <p>
     * 配置文件配置：@ Scheduled(cron = "${sue.spring.task.cron}")
     * 直接代码表达式：@ Scheduled(cron = "10 * * * * ?")
     */
    @Scheduled(cron = "10 * * * * ?")
    public void cronTask() throws InterruptedException {
        System.out.println("【SpringTask】" + Thread.currentThread().getName() + "，cronTask，" + DateUtil.date());
    }

    /**
     * 每隔5秒跑一次
     */
    @Scheduled(fixedRate = 5000)
    public void fixedRateTask() throws InterruptedException {
        System.out.println("【SpringTask】" + Thread.currentThread().getName() + "，fixedRateTask，" + DateUtil.date());
    }

    /**
     * 上次跑完隔3秒再跑
     */
    @Scheduled(fixedDelay = 3000)
    public void fixedDelayTask() throws InterruptedException {
        System.out.println("【SpringTask】" + Thread.currentThread().getName() + "，fixedDelayTask，" + DateUtil.date());
    }
}

2.4 Quartz

quartz是OpenSymphony开源组织在Job scheduling领域的开源项目，是由java开发的一个开源的任务日程管理系统。Quartz是一套轻量级的任务调度框架，只需要定义了 Job（任务），Trigger（触发器）和 Scheduler（调度器），即可实现一个定时调度能力。支持基于数据库的集群模式，可以做到任务幂等执行。
Quartz 支持任务幂等执行，其实理论上还是抢 DB 锁。quartz 表QRTZ_LOCKS 就是 Quartz 集群实现同步机制的行锁表。其中有 5 条记录，代表 5 把锁，分别用于实现多个 Quartz Node 对 Job、Trigger、Calendar 访问的同步控制。

主要方法
Scheduler 代表调度容器，一个调度容器中可以注册多个JobDetail和Trigger。
Job 代表工作，即要执行的具体内容。
JobDetail 代表具体的可执行的调度程序，Job是这个可执行程调度程序所要执行的内容。
JobBuilder 用于定义或构建JobDetail实例。
Trigger 代表调度触发器，决定什么时候去调。
TriggerBuilder 用于定义或构建触发器。
JobStore 用于存储作业和任务调度期间的状态。

使用方式
spring quartz跟spring task的cron表达式规则基本一致，只是spring4以上的版本去掉了后面的年，而quartz的CronTrigger的年是非必填的，这里我就不做过多介绍了。

优缺点
优点：默认是多线程异步执行，单个任务时，在上一个调度未完成时，下一个调度时间到时，会另起一个线程开始新的调度，多个任务之间互不影响。支持复杂的cron表达式，它能被集群实例化，支持分布式部署。
缺点：相对于spring task实现定时任务成本更高，需要手动配置QuartzJobBean、JobDetail和Trigger等。需要引入了第三方的quartz包，有一定的学习成本。不支持并行调度，不支持失败处理策略和动态分片的策略等。

操作验证
引入依赖

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

Quartz执行任务

package com.zrj.flowable.job;

import org.quartz.JobDataMap;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.scheduling.quartz.QuartzJobBean;

/**
 * Quartz执行任务
 *
 * @author zrj
 * @since 2022/4/13
 **/
public class ScheduledQuartzTask extends QuartzJobBean {
    @Override
    protected void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        JobDataMap jobDataMap = jobExecutionContext.getJobDetail().getJobDataMap();
        String taskName = (String) jobDataMap.get("taskName");
        String userName = (String) jobDataMap.get("userName");
        System.out.println("【ScheduledQuartzTask】taskName=" + taskName + "，userName=" + userName);
    }
}

Quartz配置

package com.zrj.flowable.job;

import org.quartz.*;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * Quartz配置
 *
 * @author zrj
 * @since 2022/4/13
 **/
@Configuration
public class ScheduledQuartzConfig {
    @Value("${sue.spring.quartz.cron:*/5 * * * * ?}")
    private String testCron;

    /**
     * 创建定时任务
     */
    @Bean
    public JobDetail quartzTestDetail() {
        JobDetail jobDetail = JobBuilder.newJob(ScheduledQuartzTask.class)
                .withIdentity("scheduledQuartzTask", "QUARTZ_TASK_TEST")
                .usingJobData("userName", "Jerry")
                .usingJobData("taskName", "ScheduledQuartzTask")
                .storeDurably()
                .build();
        return jobDetail;
    }

    /**
     * 创建触发器
     */
    @Bean
    public Trigger quartzTestJobTrigger() {
        //每隔5秒执行一次
        CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(testCron);

        //创建触发器
        Trigger trigger = TriggerBuilder.newTrigger()
                .forJob(quartzTestDetail())
                .withIdentity("quartzTestJobTrigger", "QUARTZ_TASK_JOB_TRIGGER")
                .withSchedule(cronScheduleBuilder)
                .build();
        return trigger;
    }

}

2.5 xxl-job

XXL-JOB是一个分布式任务调度平台，其核心设计目标是开发迅速、学习简单、轻量级、易扩展。现已开放源代码并接入多家公司线上产品线，开箱即用。xxl-job框架对quartz进行了扩展，使用mysql数据库存储数据，并且内置jetty作为RPC服务调用。主要包括调度中心和执行器，调度中心用于配置调度任务，执行器一般集成于项目，通过rpc注册到注册中心，注册中心通过配置参数实现定时调用。

另外在xxl-job对外提供的rest接口可以通过后台直接实现任务配置，业务开发中通常有一种场景，就是本身不知道何时触发执行调度任务，这时候大多采用定时周期性扫描判断是否需要执行，比如每三分钟扫一次表判断商品是否过期，然后触发下架操作，这种方式虽然与业务解耦，但是对服务器损耗比较大，浪费大量的服务资源，尤其是对实时性要求比较高的场景，还有一种解决方案是根据商品的过期时间通过xxl-job后台提供的接口创建一条执行任务，到时间自动执行相关操作，这种情况可避免不知何时触达调度而循环扫描浪费资源的情况，但是如果商品数据量巨大，创建任务量特别大的情景不如第一种更适合，两种思路，具体使用一定结合具体的业务场景使用。

主要模块
调度中心：需要搭建调度中心项目。
执行器：需要集成执行器客户端。

使用方式
官方文档极为详细，这里就不再赘述。
官方文档地址：https://www.xuxueli.com/xxl-job/
源码仓库地址 github：https://github.com/xuxueli/xxl-job
源码仓库地址 gitee：http://gitee.com/xuxueli0323/xxl-job

XXL-JOBv2.0架构图

优缺点
优点：有界面管理定时任务，支持弹性扩容缩容、动态分片、故障转移、失败报警等功能。它的功能非常强大，很多大厂在用，可以满足绝大多数业务场景。
缺点：和quartz一样，通过数据库分布式锁，来控制任务不能重复执行。在任务非常多的情况下，有一些性能问题。

操作验证
执行之前，需要完成xxl-admin管理后台部署和mysql脚本执行等这些前期准备工作。

相关依赖

<dependency>
   <groupId>com.xuxueli</groupId>
   <artifactId>xxl-job-core</artifactId>
</dependency>

applicationContext.properties文件中配置参数

xxl.job.admin.address: http://localhost:8088/xxl-job-admin/
xxl.job.executor.appname: xxl-job-executor-sample
xxl.job.executor.port: 8888
xxl.job.executor.logpath: /data/applogs/xxl-job/

HelloJobHandler

@JobHandler(value = "helloJobHandler")
@Component
public class HelloJobHandler extends IJobHandler {

    @Override
    public ReturnT<String> execute(String param) {
        System.out.println("XXL-JOB, Hello World.");
        return SUCCESS;
    }
}

2.6 elastic-job

elastic-job是当当网开发的弹性分布式任务调度系统，功能丰富强大，采用zookeeper实现分布式协调，实现任务高可用以及分片。它是专门为高并发和复杂业务场景开发。

ElasticJob 是面向互联网生态和海量任务的分布式调度解决方案，由两个相互独立的子项目 ElasticJob-Lite 和 ElasticJob-Cloud 组成。 它通过弹性调度、资源管控、以及作业治理的功能，打造一个适用于互联网场景的分布式调度解决方案，并通过开放的架构设计，提供多元化的作业生态。 它的各个产品使用统一的作业 API，开发者仅需一次开发，即可随意部署。
ElasticJob 已于 2020 年 5 月 28 日成为 Apache ShardingSphere 的子项目。elastic-job在2.x之后，出了两个产品线：Elastic-Job-Lite和Elastic-Job-Cloud，而我们一般使用Elastic-Job-Lite就能够满足需求。Elastic-Job-Lite定位为轻量级无中心化解决方案，使用jar包的形式提供分布式任务的协调服务，外部仅依赖于Zookeeper。

ElasticJob 官网地址：https://shardingsphere.apache.org/elasticjob/index_zh.html

功能列表
1.弹性调度
支持任务在分布式场景下的分片和高可用
能够水平扩展任务的吞吐量和执行效率
任务处理能力随资源配备弹性伸缩

2.资源分配
在适合的时间将适合的资源分配给任务并使其生效
相同任务聚合至相同的执行器统一处理
动态调配追加资源至新分配的任务

3.作业治理
失效转移
错过作业重新执行
自诊断修复

4.作业依赖（TODO）
基于有向无环图（DAG）的作业间依赖
基于有向无环图（DAG）的作业分片间依赖

5.作业开放生态
可扩展的作业类型统一接口
丰富的作业类型库，如数据流、脚本、HTTP、文件、大数据等
易于对接业务作业，能够与 Spring 依赖注入无缝整合

6.可视化管控端
作业管控端
作业执行历史数据追踪
注册中心管理

使用方式
ElasticJob-Lite定位为轻量级无中心化解决方案，使用 jar 的形式提供分布式任务的协调服务。

优缺点
优点：支持分布式调度协调，支持分片，适合高并发，和一些业务相对来说较复杂的场景。
缺点：依赖过重，需要依赖于zookeeper，实现定时任务相对于xxl-job要复杂一些，要对分片规则非常熟悉。

操作验证
相关依赖

<dependency>
    <groupId>com.dangdang</groupId>
    <artifactId>elastic-job-lite-core</artifactId>
</dependency>
<dependency>
    <groupId>com.dangdang</groupId>
    <artifactId>elastic-job-lite-spring</artifactId>
</dependency>

配置zookeeper

@Configuration
@ConditionalOnExpression("'${zk.serverList}'.length() > 0")
public class ZKConfig {
    @Bean
    public ZookeeperRegistryCenter registry(@Value("${zk.serverList}") String serverList,
                                             @Value("${zk.namespace}") String namespace) {
        return new ZookeeperRegistryCenter(new ZookeeperConfiguration(serverList, namespace));
    }

}

实现SimpleJob接口

public class TestJob implements SimpleJob {

    @Override
    public void execute(ShardingContext shardingContext){
        System.out.println("ShardingTotalCount:"+shardingContext.getShardingTotalCount());
        System.out.println("ShardingItem:"+shardingContext.getShardingItem());
    }
}

JobConfig配置任务

@Configuration
public class JobConfig {
    @Value("${sue.spring.elatisc.cron}")
    private String testCron;
    @Value("${sue.spring.elatisc.itemParameters}")
    private  String shardingItemParameters;
    @Value("${sue.spring.elatisc.jobParameters}")
    private String jobParameters =;
    @Value("${sue.spring.elatisc.shardingTotalCount}")
    private int shardingTotalCount;
    
    @Autowired
    private ZookeeperRegistryCenter registryCenter;

    @Bean
    public SimpleJob testJob() {
        return new TestJob();
    }

    @Bean
    public JobScheduler simpleJobScheduler(final SimpleJob simpleJob) {
        return new SpringJobScheduler(simpleJob, registryCenter, getConfiguration(simpleJob.getClass(),
                cron, shardingTotalCount, shardingItemParameters, jobParameters));
    }

    private geConfiguration getConfiguration(Class<? extends SimpleJob> jobClass,String cron,int shardingTotalCount,String shardingItemParameters,String jobParameters) {
        JobCoreConfiguration simpleCoreConfig = JobCoreConfiguration.newBuilder(jobClass.getName(), testCron, shardingTotalCount).
                shardingItemParameters(shardingItemParameters).jobParameter(jobParameters).build();
        SimpleJobConfiguration simpleJobConfig = new SimpleJobConfiguration(simpleCoreConfig, jobClass.getCanonicalName());
        LiteJobConfiguration jobConfig = LiteJobConfiguration.newBuilder(simpleJobConfig).overwrite(true).build();
        return jobConfig;
    }
}

applicationContext.properties文件中配置参数

spring.application.name=elasticjobDemo
zk.serverList=localhost:2181
zk.namespace=elasticjobDemo
sue.spring.elatisc.cron=0/5 * * * * ?
sue.spring.elatisc.itemParameters=0=A,1=B,2=C,3=D
sue.spring.elatisc.jobParameters=test
sue.spring.elatisc.shardingTotalCount=4

1 使用java.util.Timer

这种方式的定时任务主要用到两个类，Timer 和 TimerTask，使用起来比较简单。其中 Timer 负责设定 TimerTask 的起始与间隔执行时间。 TimerTask是一个抽象类，new的时候实现自己的 run 方法，然后将其丢给 Timer 去执行即可。
代码示例：

import java.time.LocalDateTime;
import java.util.Timer;
import java.util.TimerTask;

public class Schedule {
    public static void main(String[] args) {
        TimerTask timerTask = new TimerTask() {
            @Override
            public void run() {
                System.out.println("当前线程：" + Thread.currentThread().getName() + " 当前时间" + LocalDateTime.now());
            }
        };
        // 在指定延迟0毫秒后开始，随后地执行以2000毫秒间隔执行timerTask 
        new Timer().schedule(timerTask, 0L, 2000L);
        System.out.println("当前线程：" + Thread.currentThread().getName() + " 当前时间" + LocalDateTime.now());
    }
}

缺点：

• Timer 的背后只有一个线程，不管有多少个任务，都只有一个工作线程串行执行，效率低下
• 受限于单线程，如果第一个任务逻辑上死循环了，后续的任务一个都得不到执行
• 依然是由于单线程，任一任务抛出异常后，整个 Timer 就会结束，后续任务全部都无法执行

2 使用ScheduledExecutorService

ScheduledExecutorService 即是 Timer 的替代者，JDK 1.5 并发包引入，是基于线程池设计的定时任务类。每个调度任务都会分配到线程池中的某一个线程去执行，任务就是并发调度执行的，任务之间互不影响。

Java 5.0引入了java.util.concurrent包，其中的并发实用程序之一是ScheduledThreadPoolExecutor ，它是一个线程池，用于以给定的速率或延迟重复执行任务。它实际上是Timer/TimerTask组合的更通用替代品，因为它允许多个服务线程，接受各种时间单位，并且不需要子类TimerTask （只需实现Runnable）。使用一个线程配置ScheduledThreadPoolExecutor使其等效于Timer 。

代码示例：

import java.time.LocalDateTime;
import java.util.concurrent.*;

public class Schedule {
    public static void main(String[] args) {
        // 创建一个ScheduledThreadPoolExecutor线程池，核心线程数为5
        ScheduledExecutorService scheduledExecutorService = new ScheduledThreadPoolExecutor(5);
        // 创建Runnable打印当前线程和当前时间
        Runnable r = () -> System.out.println("当前线程：" + Thread.currentThread().getName() + " 当前时间" + LocalDateTime.now());
        /**
         * schedule：只执行一次调度
         * scheduleAtFixedRate：一开始就计算间隔时间，如果任务超过间隔时间，那么就直接开始下一个任务
         * scheduleWithFixedDelay：任务无论执行多久，都要等待上一轮任务完成之后再间隔指定时间，然后才开始下一个任务
         */
         // 在指定1秒延迟后执行r,之后每两秒执行一次
        scheduledExecutorService.scheduleAtFixedRate(r, 1, 2, TimeUnit.SECONDS);
    }
}

3 使用Spring Task

Spring Task 底层是基于 JDK 的 ScheduledThreadPoolExecutor 线程池来实现的。直接通过Spring 提供的 @Scheduled 注解即可定义定时任务，非常方便。

以Spring Boot来作为示例，步骤为

1. 在启动类所在包下创建Schedule 类（在没有配置@ComponentScan的情况下，Spring Boot只会默认扫描启动类所在包的spring组件）
2. 在该类上添加@Component和@EnableScheduling注解
3. 在方法上添加@Scheduled注解，该注解主要参数如下

String cron() default "";  // 支持cron表达式

long fixedDelay() default -1;  // 在最后一次调用结束和下一次调用开始之间的时间间隔，以毫秒为单位
String fixedDelayString() default "";  // 同上，类似ScheduledExecutorService的scheduleWithFixedDelay

long fixedRate() default -1;  // 在调用之前的时间间隔，以毫秒为单位
String fixedRateString() default "";  // 同上，类似ScheduledExecutorService的scheduleAtFixedRate

long initialDelay() default -1;  // 在第一次执行fixedRate()或fixedDelay()任务之前要延迟的毫秒数
String initialDelayString() default "";  // 同上

代码示例：

import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import java.time.LocalDateTime;

@Component
@EnableScheduling
public class Schedule {
    @Scheduled(fixedRate = 2000L)
    public void task() {
        System.out.println("当前线程：" + Thread.currentThread().getName() + " 当前时间" + LocalDateTime.now());
    }
}

• 优点： 简单，轻量，支持 Cron 表达式
• 缺点 ：默认只支持单机，是单线程的，并且提供的功能比较单一

可以通过@EnableAsync和 @Async开启多线程

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 org.springframework.stereotype.Component;

import java.time.LocalDateTime;

@Component
@EnableAsync  // 开启异步多线程
@EnableScheduling
public class Schedule {

    @Async
    @Scheduled(fixedRate = 2000L)
    public void task() {
        System.out.println("当前线程：" + Thread.currentThread().getName() + " 当前时间" + LocalDateTime.now());
    }
}

使用@EnableAsync注解后，默认情况下，Spring将搜索关联的线程池定义：上下文中的唯一org.springframework.core.task.TaskExecutor
的bean，或者名为“taskExecutor”的java.util.concurrent.Executor
的bean。如果两者都无法解析，则将使用org.springframework.core.task.SimpleAsyncTaskExecutor来处理异步方法调用。

TaskExecutor实现为每个任务启动一个新线程，异步执行它。 支持通过“concurrencyLimit”bean 属性限制并发线程。默认情况下，并发线程数是无限的，所以使用默认的线程池有导致内存溢出的风险。

注意：刚才的运行结果看起来是线程复用的，而实际上此实现不重用线程！应尽量实现一个线程池TaskExecutor ，特别是用于执行大量短期任务。不要使用默认的SimpleAsyncTaskExecutor。

import org.springframework.context.annotation.Bean;
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 org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
import org.springframework.stereotype.Component;

import java.time.LocalDateTime;
import java.util.concurrent.Executor;

@Component
@EnableAsync
@EnableScheduling
public class Schedule {

    @Async
    @Scheduled(fixedRate = 2000L)
    public void task() {
        System.out.println("当前线程：" + Thread.currentThread().getName() + " 当前时间" + LocalDateTime.now());
    }


    @Bean("taskExecutor")
    public Executor taskExecutor() {
        ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
        taskExecutor.setCorePoolSize(10);
        taskExecutor.setMaxPoolSize(50);
        taskExecutor.setQueueCapacity(200);
        taskExecutor.setKeepAliveSeconds(60);
        taskExecutor.setThreadNamePrefix("自定义-");
        taskExecutor.setAwaitTerminationSeconds(60);
        return taskExecutor;
    }
}

上面提到的一些定时任务的解决方案都是在单机下执行的，适用于比较简单的定时任务场景比如每天凌晨备份一次数据。如果我们需要一些高级特性比如支持任务在分布式场景下的分片和高可用的话，我们就需要用到分布式任务调度框架了，比如Quartz、Elastic-Job、XXL-JOB、PowerJob，本文就不再详细进行介绍了，感兴趣的可以自行查阅相关资料。