1. 总结常见的实现定时任务的几种方法

thread实现 【原理：通过创建一个线程，让他在while循环里面一直运行，用sleep() 方法让其休眠从而达到定时任务的效果。】

Timer类

ScheduledExcecutorService类

使用spring的 spring-task 实现

Quartz

以下演示几种实现方式：每隔一秒打印一次hello world

1.1 thread实现

public static void main(String[] args) {

final long timeInterval = 1000;

Runnable runnable = new Runnable() {

@Override

public void run() {

while (true) {

System.out.println("hello world");

try {

Thread.sleep(timeInterval);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

};

Thread thread = new Thread(runnable);

thread.start();

}

1.2 Timer类实现

Timer是jdk中自带的一个定时器工具，使用的时候会在主线程之外起一个单独的线程执行指定的计划任务，可以指定执行一次或者反复执行多次。但封装任务的类是TimerTask类(实际该类是一个抽象类，执行任务的代码要放在该类的子类中)。

TimerTask是一个实现了Runnable接口的抽象类，代表一个可以被Timer执行的任务。

构造方法：

成员方法：

public static void main(String[] args) {

TimerTask task = new TimerTask() {

@Override

public void run() {

System.out.println("Hello!Word!");

}

};

Timer timer = new Timer();

long delay = 0;

long intevalPeriod = 1 * 1000;

timer.scheduleAtFixedRate(task, delay, intevalPeriod);

}

schedule 与 scheduleAtFixedRate区别：

schedule会保证任务的间隔是按照定义的period参数严格执行的，如果某一次调度时间比较长，那么后面的时间会顺延，保证调度间隔都是period。

scheduleAtFixedRate是严格按照调度时间来的，如果某次调度时间太长了，那么会通过缩短间隔的方式保证下一次调度在预定时间执行。

线程安全, 但只会单线程执行, 如果执行时间过长, 就错过下次任务了, 抛出异常时, timerWork会终止

启动和取消任务是可以控制的

1.3 ScheduledExcecutorService类实现

ScheduledExecutorService是JDK1.5以后java.util.concurrent中的一个接口, 用于实现定时任务。

public static void main(String[] args) {

Runnable r1 = new Runnable() {

public void run() {

System.out.println("Hello Word");

}

};

ScheduledExecutorService service = Executors.newSingleThreadScheduledExecutor();

// 第二个参数为首次执行的延时时间，第三个参数为定时执行的间隔时间

service.scheduleAtFixedRate(r1, 3, 1, TimeUnit.SECONDS);// 3秒后开始执行

}

他是通过线程池的方式执行任务，可以多线程执行。

启动和取消任务是可以控制的

可以设定第一次的延迟时间

1.4 使用spring提供的 spring-task 实现

a) 只需要导入web的starter依赖

b) 在启动类上添加 @EnableScheduling 注解

c) 用 @Scheduled 注解开启一个定时任务。

@Component

public class SchedulerTask {

private int count = 0;

/**

* @Author Smith

* @Description 设置每1秒执行一次

* @Date 14:23 2019/1/24

* @Param

* @return void

**/

@Scheduled(cron = "*/1 * * * * ?") // 基于cron表达式实现

private void process(){

System.out.println("hello world " + (count++));

}

}

@Scheduled 该注解的常用参数说明【不基于cron表达式实现的时候】：

fixedRate 表示任务执行之间的时间间隔，具体是指两次任务的开始时间间隔，即第二次任务开始时，第一次任务可能还没结束。

fixedDelay 表示任务执行之间的时间间隔，具体是指本次任务结束到下次任务开始之间的时间间隔。

initialDelay 表示首次任务启动的延迟时间。

所有时间的单位都是毫秒。

1.5 Quartz

参考

源码

Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目，它可以与J2EE与J2SE应用程序相结合也可以单独使用。Quartz可以用来创建简单或为运行十个，百个，甚至是好几万个Jobs这样复杂的程序。

Quartz默认是多线程异步执行，单个任务时，在上一个调度未完成时，下一个调度时间到时，会另起一个线程开始新的调度。

Quartz支持集群定时任务

Quartz与Spring Task区别

Quartz默认多线程异步执行，Task默认单线程同步执行。

Quartz单个任务时，在上一个调度未完成时，下一个调度时间到时，会另起一个线程开始新的调度。Task单个任务时，当前次的调度完成后，再执行下一次任务调度。

Quartz多个任务时，任务之间没有直接影响，多任务执行的快慢取决于CPU的性能。Task多个任务时，一个任务执行完成后才会执行下一个任务。若需要任务能够并发执行，需手动设置线程池

Quartz可以采用集群方式，分布式部署到多台机器，分配执行定时任务

两者对比总结：

1、实现，Task注解实现方式，比较简单。Quartz需要手动配置Jobs。

2、任务执行，Task默认单线程串行执行任务，多任务时若某个任务执行时间过长，后续任务会无法及时执行。Quartz采用多线程，无这个问题。

3、调度，Task采用顺序执行，若当前调度占用时间过长，下一个调度无法及时执行；

4、Quartz采用异步，下一个调度时间到达时，会另一个线程执行调度，不会发生阻塞问题，但调度过多时可能导致数据处理异常

5、部署，Quartz可以采用集群方式，分布式部署到多台机器，分配执行定时任务

Quartz 核心概念：

a) Job 表示一个工作，要执行的具体内容。此接口中只有一个方法。Task多个任务时，一个任务执行完成后才会执行下一个任务。若需要任务能够并发执行，需手动设置线程池。

void execute(JobExecutionContext context)

b) JobDetail 表示一个具体的可执行的调度程序，Job 是这个可执行程调度程序所要执行的内容，另外 JobDetail 还包含了这个任务调度的方案和策略。

c) Trigger 代表一个调度参数的配置，什么时候去调。

d) Scheduler 代表一个调度容器，一个调度容器中可以注册多个 JobDetail 和 Trigger。当 Trigger 与 JobDetail 组合，就可以被 Scheduler 容器调度了。

Spring Boot整合Quartz：

导入Quartz依赖

org.springframework.boot

spring-boot-starter-quartz

编写任务类

public class Task implements Job {

// 任务类不能直接注入Bean，若想注入Bean需要配置第4步

@Autowired

private TestService service;

private void before(){

System.out.println("定时任务开始");

}

@Override

public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {

service.testDemo();

System.out.println("hello quartz");

}

private void afer(){

System.out.println("定时任务结束");

}

}

★ 任务类不能直接注入Bean，若想注入Bean需要配置第4步 ★

编写Quartz配置

@Configuration

public class QuartzConfig {

@Bean

public JobDetailFactoryBean jobDetailFactoryBean() {

JobDetailFactoryBean factory = new JobDetailFactoryBean();

//关联我们自己的Job类

factory.setJobClass(Task.class);

return factory;

}

@Bean

public CronTriggerFactoryBean cronTriggerFactoryBean(JobDetailFactoryBean jobDetailFactoryBean) {

CronTriggerFactoryBean factory = new CronTriggerFactoryBean();

factory.setJobDetail(jobDetailFactoryBean.getObject());

//设置触发时间

factory.setCronExpression("0/2 * * * * ?");

return factory;

}

@Bean

public SchedulerFactoryBean schedulerFactoryBean(CronTriggerFactoryBean cronTriggerFactoryBean, MyAdaptableJobFactory jobFactory) {

SchedulerFactoryBean factory = new SchedulerFactoryBean();

//关联trigger

factory.setTriggers(cronTriggerFactoryBean.getObject());

factory.setJobFactory(jobFactory);

return factory;

}

}

编写配置【用于任务类能注入我们的bean】

@Component

public class MyAdaptableJobFactory extends AdaptableJobFactory {

// 可以将一个对象添加到SpringIOC 容器中，并且完成该对象注入

@Autowired

private AutowireCapableBeanFactory autowireCapableBeanFactory;

/**

* 该方法需要将实例化的任务对象手动的添加到springIOC 容器中并且完成对象的注入

*/

@Override

protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {

Object obj = super.createJobInstance(bundle);

//将obj 对象添加Spring IOC 容器中，并完成注入

this.autowireCapableBeanFactory.autowireBean(obj);

return obj;

}

}

2 Quartz[群集环境]

使用quartz实现定时任务[单机版]，若是部署多台机器，那么到了时间点，多台服务器便会同时均开始执行定时任务。

Quartz是能适用于分布式集群环境的，在同一时间只会有一台机器执行定时任务。

Quartz 中集群如何工作:

一个 Quartz 集群中的每个节点是一个独立的 Quartz 应用，它又管理着其他的节点。意思是你必须对每个节点分别启动或停止。不像许多应用服务器的集群，独立的 Quartz 节点并不与另一其的节点或是管理节点通信。Quartz 应用是通过数据库表来感知到另一应用的。离开了db将无法感知

2.1 导入依赖

org.springframework.boot

spring-boot-starter-quartz

2.2 数据库建表

到官网下载

下载之后解压，进入如下目录，创建数据库表:

11张表功能说明：