本文介绍Spring3.0以后自主开发的定时任务工具，spring task，可以将它比作一个轻量级的Quartz，而且使用起来很简单，除spring相关的包外不需要额外的包，而且支持注解和配置文件两种，这里我们介绍注解的形式
形式，下面将分别介绍这两种方式。
第一步：编写作业类
import org.springframework.stereotype.Service;    
 @Service
public class TaskJob {    
  public void deleteFrontFile() {    
  	System.out.println(“任务进行中。。。”);    
    }    
}   


第二步：在spring配置文件头中添加命名空间及描述

<beans xmlns="http://www.springframework.org/schema/beans"    
    xmlns:task="http://www.springframework.org/schema/task"     
    xsi:schemaLocation="http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-3.0.xsd">



第三步：spring配置文件中设置具体的任务
<!-- 定时任务task -->
	<task:scheduled-tasks>
		<task:scheduled ref="taskJob" method="deleteFrontFile" cron="0 30 8 * * ?" />
	</task:scheduled-tasks>
	<context:component-scan base-package="com.askingdee.htgl.common.task" />

说明：ref参数指定的即任务类，method指定的即需要运行的方法，cron及cronExpression表达式，具体写法这里不介绍了，详情见上篇文章附录。
这个配置不需要多说了，spring扫描注解用的。
到这里配置就完成了，是不是很简单。

本文的主要内容是将java的几个分布式定时任务框架做个对比总结。
【框架列举】
单机
1.timer：是一个定时器类，通过该类可以为指定的定时任务进行配置。TimerTask类是一个定时任务类，该类实现了Runnable接口，缺点异常未检查会中止线程
2.ScheduledExecutorService：相对延迟或者周期作为定时任务调度，缺点没有绝对的日期或者时间
3.spring定时框架：配置简单功能较多，如果系统使用单机的话可以优先考虑spring定时器
分布
1.Quartz：Java事实上的定时任务标准。但Quartz关注点在于定时任务而非数据，并无一套根据数据处理而定制化的流程。虽然Quartz可以基于数据库实现作业的高可用，但缺少分布式并行调度的功能
2.Spring batch：轻量级的，完全面向Spring的批处理框架，可以应用于企业级大量的数据处理系统。Spring Batch以POJO和Spring框架为基础，使开发者更容易的访问和利用企业级.服务。Spring Batch可以提供大量的，可重复的数据处理功能，包括日志记录/跟踪，事务管理，作业处理统计工作重新启动、跳过，和资源管理等重要功能。
3.TBSchedule：阿里早期开源的分布式任务调度系统。使用timer而非线程池执行任务调度。众所周知，timer在处理异常状况时是有缺陷的。而且TBSchedule作业类型较为单一，只能是获取/处理数据一种模式。文档缺失比较严重。
4.elastic-job：当当开发的弹性分布式任务调度系统，功能丰富强大，采用zookeeper实现分布式协调，实现任务高可用以及分片，目前是版本2.15，并且可以支持云开发
5.xxl-job: 是大众点评员工徐雪里于2015年发布的分布式任务调度平台，是一个轻量级分布式任务调度框架，其核心设计目标是开发迅速、学习简单、轻量级、易扩展。
【加群】：857565362
【框架对比】
下面主要将xxl-job和elastic-job进行简单对比。
公司
     x-job：个人，大众点评公司员工许雪里，贡献者3人；
     e-job：当当网开源，贡献者17人；
支持集群部署
     x-job：保证每个集群节点配置（db和登陆账号等）保持一致。调度中心通过db配置区分不同集群。执行器支持集群部署，提升调度系统可用性，同时提升任务处理能力。集群部署唯一要求为：保证集群中每个执行器的配置项 “xxl.job.admin.addresses/调度中心地址” 保持一致，执行器根据该配置进行执行器自动注册等操作。
    e-job：重写Quartz基于数据库的分布式功能，用Zookeeper实现注册中心。作业注册中心： 基于Zookeeper和其客户端Curator实现的全局作业注册控制中心。用于注册，控制和协调分布式作业执行。
多节点部署时任务不能重复执行
    x-job：使用Quartz基于数据库的分布式功能
    e-job：将任务拆分为n个任务项后，各个服务器分别执行各自分配到的任务项。一旦有新的服务器加入集群，或现有服务器下线，elastic-job将在保留本次任务执行不变的情况下，下次任务开始前触发任务重分片。
日志
    x-job：支持日志可追溯，有日志查询界面
    e-job：可通过事件订阅的方式处理调度过程的重要事件，用于查询、统计和监控。Elastic-Job目前提供了基于关系型数据库两种事件订阅方式记录事件
监控报警
    x-job：调度失败时，将会触发失败报警，如发送报警邮件。任务调度失败时邮件通知的邮箱地址，支持配置多邮箱地址，配置多个邮箱地址时用逗号分隔
    e-job：通过事件订阅方式可自行实现
弹性扩容缩容
    x-job：使用Quartz基于数据库的分布式功能，服务器超出一定数量会给数据库造成一定的压力
    e-job：通过zk实现各服务的注册、控制及协调
支持并行调度
     x-job：调度系统多线程（默认10个线程）触发调度运行，确保调度精确执行，不被堵塞
     e-job：采用任务分片方式实现。将一个任务拆分为n个独立的任务项，由分布式的服务器并行执行各自分配到的分片项
高可用策略
    x-job：“调度中心”通过DB锁保证集群分布式调度的一致性, 一次任务调度只会触发一次执行
    e-job：调度器的高可用是通过运行几个指向同一个ZooKeeper集群的Elastic-Job-Cloud-Scheduler实例来实现的。ZooKeeper用于在当前主Elastic-Job-Cloud-Scheduler实例失败的情况下执行领导者选举。通过至少两个调度器实例来构成集群，集群中只有一个调度器实例提供服务，其他实例处于”待命”状态。当该实例失败时，集群会选举剩余实例中的一个来继续提供服务
失败处理策略
     x-job：调度失败时的处理策略，策略包括：失败告警（默认）、失败重试
     e-job：弹性扩容缩容在下次作业运行前重分片，但本次作业执行的过程中，下线的服务器所分配的作业将不会重新被分配。失效转移功能可以在本次作业运行中用空闲服务器抓取孤儿作业分片执行。同样失效转移功能也会牺牲部分性能
【对比总结】
共同点
x-Job和e-job都有广泛的用户基础和完整的技术文档，都能满足定时任务的基本功能需求。
不同点
    x-Job 侧重的业务实现的简单和管理的方便，学习成本简单，失败策略和路由策略丰富。推荐使用在“用户基数相对少，服务器数量在一定范围内”的情景下使用
    e-Job 关注的是数据，增加了弹性扩容和数据分片的思路，以便于更大限度的利用分布式服务器的资源。但是学习成本相对高些，推荐在“数据量庞大，且部署服务器数量较多”时使用
【学习总结】
考虑公司项目进度，优先选择了学习成本较低的x-job，对比总结是学习x-job的一个基石，有了宏观认识，才能更好地深入。
我这儿整理了比较全面的JAVA相关的面试资料，
需要领取面试资料的同学，请加群：473984645
获取更多学习资料，可以加群：473984645或扫描下方二维码

@[TOC]java定时任务
Java定时任务
Java开发过程中经常会遇到使用定时任务的情况，我总结了一下有如下四种方式：Timer、ScheduledExecutorService、SpringTask、Quartz。
一、使用java的Timer

1、Timer
new Timer("testTimer").schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("TimerTask");
            }
        }, 1000,2000);

解释：1000ms是延迟启动时间，2000ms是定时任务周期，每2s执行一次
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
try {
	Date date = dateFormat.parse("2018-07-11 12:00:00.000");
	new Timer("testTimer1").scheduleAtFixedRate(new TimerTask() {
		@Override
		public void run() {
			System.out.println("TimerTask");
		}
	}, date,2000);
} catch (ParseException e) {
	e.printStackTrace();
}

解释：date是开始时间，2000ms是定时任务周期，每2s执行一次

timer有2中方法schedule和scheduleAtFixedRate，前者会等任务结束在开始计算时间间隔，后者是在任务开始就计算时间，有并发的情况
二、使用ScheduledExecutorService

1、ScheduledExecutorService
scheduledExecutorService.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("ScheduledTask");
            }
        },1, TimeUnit.SECONDS);

解释：延迟1s启动，执行一次
ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(10);
        scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.println("ScheduledTask");
            }
        }, 1, 1, TimeUnit.SECONDS);

解释：延迟1s启动，每隔1s执行一次，是前一个任务开始时就开始计算时间间隔，但是会等上一个任务结束在开始下一个
ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(10);
        scheduledExecutorService.scheduleWithFixedDelay(new Runnable() {
            @Override
            public void run() {
                System.out.println("ScheduledTask");
            }
        }, 1, 1, TimeUnit.SECONDS);

解释：延迟1s启动，在前一个任务执行完成之后，延迟1s在执行
三、使用SpringTask

1、写任务类
package com.zb.timedtask;
import com.zb.controller.StudentController;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;

@Service
public class SpringTask {
    private static final Logger log = LoggerFactory.getLogger(SpringTask.class);

    @Scheduled(cron = "1/5 * * * * *")
    public void task1(){
        log.info("springtask 定时任务！");
    }
	
	@Scheduled(initialDelay = 1000,fixedRate = 1*1000)
    public void task2(){
        log.info("springtask 定时任务！");
    }
}

解释：

task1是每隔5s执行一次，{秒} {分} {时} {日期} {月} {星期}

task2是延迟1s,每隔1S执行一次
2、配置文件修改

（1）简单版
<task:annotation-driven/>

（2）任务池版
<task:executor id="executor" pool-size="10" />
<task:scheduler id="scheduler" pool-size="10" />
<task:annotation-driven executor="executor" scheduler="scheduler" />

（3）解释

假如只有一个定时任务，可以用简单版；如果有多个定时任务，则要用任务池，不然它会顺序执行。
两个任务的时间间隔为：执行时间+设定的定时间隔
例子：(这个任务8s执行一次)
@Scheduled(cron = "1/4 * * * * *")
public void task2(){
	log.info("springtask 定时任务2！");
	try {
		TimeUnit.SECONDS.sleep(4);
	} catch (InterruptedException e) {
		e.printStackTrace();
	}
}

四、使用Quartz框架

1、加依赖
<!-- quartz -->
<dependency>
  <groupId>org.quartz-scheduler</groupId>
  <artifactId>quartz</artifactId>
  <version>2.3.0</version>
</dependency>
<!--调度器核心包-->
<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-context-support</artifactId>
	<version>4.3.4.RELEASE</version>
</dependency>

2、Job实现
package com.zb.quartz;

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class HelloWorldJob implements Job {
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        String strTime = new SimpleDateFormat("HH-mm-ss").format(new Date());
        System.out.println( strTime + ":Hello World！");
    }
}

3、调度器(可以用listener在项目启动时执行)
import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;

public class MyScheduler {
    public static void main(String[] args) throws SchedulerException {
        //创建调度器Schedule
        SchedulerFactory schedulerFactory = new StdSchedulerFactory();
        Scheduler scheduler = schedulerFactory.getScheduler();
        //创建JobDetail实例，并与HelloWordlJob类绑定
        JobDetail jobDetail = JobBuilder.newJob(HelloWorldJob.class).withIdentity("job1", "jobGroup1")
                .build();
        //创建触发器Trigger实例(立即执行，每隔1S执行一次)
        Trigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("trigger1", "triggerGroup1")
                .startNow()
                .withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(1).repeatForever())
                .build();
        //开始执行
        scheduler.scheduleJob(jobDetail, trigger);
        scheduler.start();
    }
}

解释：上面用的是简单触发器，也可以用Con触发器，如下
Trigger cronTrigger = TriggerBuilder.newTrigger()
                .withIdentity("trigger2", "triggerGroup2")
                .startNow()
                .withSchedule(cronSchedule("0 42 10 * * ?"))
                .build();

4、整合spring

也可以直接把上面的调度器写成配置文件，整合spring
（1）job
package com.zb.quartz;
import java.text.SimpleDateFormat;
import java.util.Date;

public class QuarFirstJob {
    public void first() {
        String strTime = new SimpleDateFormat("HH-mm-ss").format(new Date());
        System.out.println( strTime + ":Hello World！");
    }
}

（2）配置文件
<bean id="QuarFirstJob" class="com.zb.quartz.QuarFirstJob" />

<bean id="jobDetail"
	  class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
	<property name="group" value="quartzGroup1" />
	<property name="name" value="quartzJob1" />
	<!--false表示等上一个任务执行完后再开启新的任务 -->
	<property name="concurrent" value="false" />
	<property name="targetObject">
		<ref bean="QuarFirstJob" />
	</property>
	<property name="targetMethod">
		<value>first</value>
	</property>
</bean>

<!-- 调度触发器 -->
<bean id="myTrigger"
	  class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
	<property name="name" value="trigger1" />
	<property name="group" value="group1" />
	<property name="jobDetail">
		<ref bean="jobDetail" />
	</property>
	<property name="cronExpression">
		<value>0/5 * * * * ?</value>
	</property>
</bean>

<!-- 调度工厂 -->
<bean id="scheduler"
	  class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
	<property name="triggers">
		<list>
			<ref bean="myTrigger" />
		</list>
	</property>
</bean>

5、时间
public class QuarFirstJob {
    public void first() {
        try {
            TimeUnit.SECONDS.sleep(6);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        String strTime = new SimpleDateFormat("HH-mm-ss").format(new Date());
        System.out.println( strTime + ":Hello World！");
    }
}

上面的配置里面写是5s间隔，把上面的sleep时间分别改成4和6，发现两次任务间隔是执行时间和间隔时间的最大值，分别是5,6
总结

Quartz是执行时间和间隔时间的最大值(比如；执行时间是3s,间隔是2s,则每3s执行一次；执行时间是3s,间隔是5s,则每5s执行一次。)

Spring task是执行时间+间隔时间(比如；执行时间是3s,间隔是2s,则每5s执行一次；执行时间是3s,间隔是5s,则每8s执行一次。)

timer有2中方法schedule和scheduleAtFixedRate，前者会等任务结束在开始计算时间间隔，后者是在任务开始就计算时间，有并发的情况

ScheduledExecutorService的scheduleAtFixedRate类似Quartz，scheduleWithFixedDelay类似SpringTaskJava定时任务

Java开发过程中经常会遇到使用定时任务的情况，我总结了一下有如下四种方式：Timer、ScheduledExecutorService、SpringTask、Quartz。

Java开发过程中经常会遇到使用定时任务的情况，我总结了一下有如下四种方式：Timer、ScheduledExecutorService、SpringTask、Quartz。
一、使用java的Timer
1、Timer
new Timer("testTimer").schedule(new TimerTask() {
@Override
public void run() {
System.out.println("TimerTask");
}
}, 1000,2000);
解释：1000ms是延迟启动时间，2000ms是定时任务周期，每2s执行一次
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
try {
Date date = dateFormat.parse("2018-07-11 12:00:00.000");
new Timer("testTimer1").scheduleAtFixedRate(new TimerTask() {
@Override
public void run() {
System.out.println("TimerTask");
}
}, date,2000);
} catch (ParseException e) {
e.printStackTrace();
}
解释：date是开始时间，2000ms是定时任务周期，每2s执行一次
timer有2中方法schedule和scheduleAtFixedRate，前者会等任务结束在开始计算时间间隔，后者是在任务开始就计算时间，有并发的情况
二、使用ScheduledExecutorService
1、ScheduledExecutorService
scheduledExecutorService.schedule(new Runnable() {
@Override
public void run() {
System.out.println("ScheduledTask");
}
},1, TimeUnit.SECONDS);
解释：延迟1s启动，执行一次
ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(10);
scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
System.out.println("ScheduledTask");
}
}, 1, 1, TimeUnit.SECONDS);
解释：延迟1s启动，每隔1s执行一次，是前一个任务开始时就开始计算时间间隔，但是会等上一个任务结束在开始下一个
ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(10);
scheduledExecutorService.scheduleWithFixedDelay(new Runnable() {
@Override
public void run() {
System.out.println("ScheduledTask");
}
}, 1, 1, TimeUnit.SECONDS);
解释：延迟1s启动，在前一个任务执行完成之后，延迟1s在执行
三、使用SpringTask
1、写任务类
package com.zb.timedtask;
import com.zb.controller.StudentController;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;
@Service
public class SpringTask {
private static final Logger log = LoggerFactory.getLogger(SpringTask.class);
@Scheduled(cron = "1/5 * * * * *")
public void task1(){
log.info("springtask 定时任务！");
}
@Scheduled(initialDelay = 1000,fixedRate = 1*1000)
public void task2(){
log.info("springtask 定时任务！");
}
}
解释：
task1是每隔5s执行一次，{秒} {分} {时} {日期} {月} {星期}
task2是延迟1s,每隔1S执行一次
2、配置文件修改
(1)简单版
(2)任务池版
(3)解释
假如只有一个定时任务，可以用简单版；如果有多个定时任务，则要用任务池，不然它会顺序执行。
两个任务的时间间隔为：执行时间+设定的定时间隔
例子：(这个任务8s执行一次)
@Scheduled(cron = "1/4 * * * * *")
public void task2(){
log.info("springtask 定时任务2！");
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
四、使用Quartz框架
1、加依赖
org.quartz-scheduler
quartz
2.3.0
org.springframework
spring-context-support
4.3.4.RELEASE
2、Job实现
package com.zb.quartz;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class HelloWorldJob implements Job {
@Override
public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
String strTime = new SimpleDateFormat("HH-mm-ss").format(new Date());
System.out.println( strTime + ":Hello World！");
}
}
3、调度器(可以用listener在项目启动时执行)
import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;
public class MyScheduler {
public static void main(String[] args) throws SchedulerException {
//创建调度器Schedule
SchedulerFactory schedulerFactory = new StdSchedulerFactory();
Scheduler scheduler = schedulerFactory.getScheduler();
//创建JobDetail实例，并与HelloWordlJob类绑定
JobDetail jobDetail = JobBuilder.newJob(HelloWorldJob.class).withIdentity("job1", "jobGroup1")
.build();
//创建触发器Trigger实例(立即执行，每隔1S执行一次)
Trigger trigger = TriggerBuilder.newTrigger()
.withIdentity("trigger1", "triggerGroup1")
.startNow()
.withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(1).repeatForever())
.build();
//开始执行
scheduler.scheduleJob(jobDetail, trigger);
scheduler.start();
}
}
解释：上面用的是简单触发器，也可以用Con触发器，如下
Trigger cronTrigger = TriggerBuilder.newTrigger()
.withIdentity("trigger2", "triggerGroup2")
.startNow()
.withSchedule(cronSchedule("0 42 10 * * ?"))
.build();
4、整合spring
也可以直接把上面的调度器写成配置文件，整合spring
(1)job
package com.zb.quartz;
import java.text.SimpleDateFormat;
import java.util.Date;
public class QuarFirstJob {
public void first() {
String strTime = new SimpleDateFormat("HH-mm-ss").format(new Date());
System.out.println( strTime + ":Hello World！");
}
}
(2)配置文件
class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
first
class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
0/5 * * * * ?
class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
5、时间
public class QuarFirstJob {
public void first() {
try {
TimeUnit.SECONDS.sleep(6);
} catch (InterruptedException e) {
e.printStackTrace();
}
String strTime = new SimpleDateFormat("HH-mm-ss").format(new Date());
System.out.println( strTime + ":Hello World！");
}
}
上面的配置里面写是5s间隔，把上面的sleep时间分别改成4和6，发现两次任务间隔是执行时间和间隔时间的最大值，分别是5,6
总结
Quartz是执行时间和间隔时间的最大值(比如；执行时间是3s,间隔是2s,则每3s执行一次；执行时间是3s,间隔是5s,则每5s执行一次。)
Spring task是执行时间+间隔时间(比如；执行时间是3s,间隔是2s,则每5s执行一次；执行时间是3s,间隔是5s,则每8s执行一次。)
timer有2中方法schedule和scheduleAtFixedRate，前者会等任务结束在开始计算时间间隔，后者是在任务开始就计算时间，有并发的情况
ScheduledExecutorService的scheduleAtFixedRate类似Quartz，scheduleWithFixedDelay类似SpringTask