jdk自带定时调度类Timer和定时任务类TimerTask及spring的定时任务

本文主要是介绍jdk自带定时调度类Timer和定时任务类TimerTask及spring的定时任务，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

java定时器Timer原理：https://www.cnblogs.com/luckygxf/p/7078662.html

TBschedule分布式定时任务调度框架

传统的调度框架spring task、quartz也是可以进行集群调度作业的，一个节点挂了可以将任务漂移给其他节点执行从而避免单点故障，但是不支持分布式作业，一旦达到单机处理极限也会存在问题。

jdk自带定时调度类Timer和定时任务类TimerTask

Timer:

构造方法(不论哪个构造函数最后都会创建新线程TimerThread并调用含有启动该线程start()方法的构造函数)：

也就是说创建一个Timer对象就相当于启动了一个TimerThread线程￥1

public Timer()
{
this("Timer-" + serialNumber());
}

public Timer(boolean paramBoolean)
{
this("Timer-" + serialNumber(), paramBoolean);
}

public Timer(String paramString)
{
this.thread.setName(paramString);
this.thread.start();
}

public Timer(String paramString, boolean paramBoolean)
{
this.thread.setName(paramString);
this.thread.setDaemon(paramBoolean);//是否设为守护线程/后台(后台程序的后台)线程，在后台运行直到进程结束。
this.thread.start();

}

线程启动后执行的run方法：

public void run()
{
try
{
mainLoop();
synchronized (this.queue)
{
this.newTasksMayBeScheduled = false;
this.queue.clear();
}
}
finally
{
synchronized (this.queue)
{
this.newTasksMayBeScheduled = false;
this.queue.clear();
}
}
}

private void mainLoop()
{
try
{
for (;;) // 无线循环直到遇到break退出
{
TimerTask localTimerTask;
int i;
synchronized (this.queue)
{
if ((this.queue.isEmpty()) && (this.newTasksMayBeScheduled))
{
this.queue.wait(); continue;
}
if (this.queue.isEmpty()) {
break;
}
localTimerTask = this.queue.getMin();
long l1;
long l2;
synchronized (localTimerTask.lock)
{
if (localTimerTask.state == 3)
{
this.queue.removeMin();
continue;
}
l1 = System.currentTimeMillis();
l2 = localTimerTask.nextExecutionTime;
if ((i = l2 <= l1 ? 1 : 0) != 0) {
if (localTimerTask.period == 0L)
{
this.queue.removeMin();
localTimerTask.state = 2;
}
else
{
this.queue.rescheduleMin(localTimerTask.period < 0L ? l1 - localTimerTask.period : l2 + localTimerTask.period);
}
}
}
if (i == 0) {
this.queue.wait(l2 - l1);
}
}
if (i != 0) {
localTimerTask.run();
}
}
}
catch (InterruptedException localInterruptedException) {}
}

调度方法：

public void schedule(TimerTask paramTimerTask, long paramLong)
{paramLong后调度一次
if (paramLong < 0L) {
throw new IllegalArgumentException("Negative delay.");
}
sched(paramTimerTask, System.currentTimeMillis() + paramLong, 0L);
}

public void schedule(TimerTask paramTimerTask, Date paramDate)
{在指定时间paramDate处调度一次
sched(paramTimerTask, paramDate.getTime(), 0L);
}

public void schedule(TimerTask paramTimerTask, long paramLong1, long paramLong2)
{paramLong1后开始调度，完成后至少等待paramLong2这么久再次调度
if (paramLong1 < 0L) {
throw new IllegalArgumentException("Negative delay.");
}
if (paramLong2 <= 0L) {
throw new IllegalArgumentException("Non-positive period.");
}
sched(paramTimerTask, System.currentTimeMillis() + paramLong1, -paramLong2);
}

public void schedule(TimerTask paramTimerTask, Date paramDate, long paramLong)
{在paramDate处开始调度，完成后至少等待paramLong这么久再次调度
if (paramLong <= 0L) {
throw new IllegalArgumentException("Non-positive period.");
}
sched(paramTimerTask, paramDate.getTime(), -paramLong);
}

public void scheduleAtFixedRate(TimerTask paramTimerTask, long paramLong1, long paramLong2)
{paramLong1后开始调度，若调度被推迟完成，完成后按第一次调度计划时间+paramLong2来进行下一次调度
if (paramLong1 < 0L) {
throw new IllegalArgumentException("Negative delay.");
}
if (paramLong2 <= 0L) {
throw new IllegalArgumentException("Non-positive period.");
}
sched(paramTimerTask, System.currentTimeMillis() + paramLong1, paramLong2);
}

public void scheduleAtFixedRate(TimerTask paramTimerTask, Date paramDate, long paramLong)
{在paramDate处开始调度，若调度被推迟完成，完成后按第一次调度计划时间+paramLong2来进行下一次调度
if (paramLong <= 0L) {
throw new IllegalArgumentException("Non-positive period.");
}
sched(paramTimerTask, paramDate.getTime(), paramLong);
}

上面所有方法最后调sched(paramTimerTask, paramDate.getTime(), paramLong);方法时传入的都是开始执行的时间。

private void sched(TimerTask paramTimerTask, long paramLong1, long paramLong2)
{
if (paramLong1 < 0L) {
throw new IllegalArgumentException("Illegal execution time.");
}
if (Math.abs(paramLong2) > 4611686018427387903L) {
paramLong2 >>= 1; 即paramLong2=paramLong2 >>1(基于二进制向右移一位)
}
synchronized (this.queue)
{
if (!this.thread.newTasksMayBeScheduled) {
throw new IllegalStateException("Timer already cancelled.");
}
synchronized (paramTimerTask.lock)
{
if (paramTimerTask.state != 0) {
throw new IllegalStateException("Task already scheduled or cancelled");
}
paramTimerTask.nextExecutionTime = paramLong1;
paramTimerTask.period = paramLong2;
paramTimerTask.state = 1;
}
this.queue.add(paramTimerTask);
if (this.queue.getMin() == paramTimerTask) {
this.queue.notify();
}
}

}

https://www.cnblogs.com/dolphin0520/p/3938991.html

http://code.taobao.org/p/tbschedule/wiki/index/

TBschedule业务接口说明

包含三个业务接口，：
1、IScheduleTaskDeal 调度器对外的基础接口，是一个基类，并不能被直接使用
2、IScheduleTaskDealSingle 单任务处理的接口,继承 IScheduleTaskDeal
3、IScheduleTaskDealMulti 可批处理的任务接口,继承 IScheduleTaskDeal

IScheduleTaskDeal 调度器对外的基础接口

public interface IScheduleTaskDeal<T> {
/*** 根据条件，查询当前调度服务器可处理的任务	* @param taskParameter 任务的自定义参数* @param ownSign 当前环境名称* @param taskQueueNum 当前任务类型的任务队列数量* @param taskQueueList 当前调度服务器，分配到的可处理队列* @param eachFetchDataNum 每次获取数据的数量* @return* @throws Exception*/
public List<T> selectTasks(String taskParameter,String ownSign,int taskQueueNum,List<TaskItemDefine> taskItemList,int eachFetchDataNum) throws Exception;/*** 获取任务的比较器,只有在NotSleep模式下需要用到* @return*/
public Comparator<T> getComparator();
}

IScheduleTaskDealSingle 单任务处理的接口

public interface IScheduleTaskDealSingle<T> extends IScheduleTaskDeal<T> {/*** 执行单个任务* @param task Object* @param ownSign 当前环境名称* @throws Exception*/public boolean execute(T task,String ownSign) throws Exception;}

IScheduleTaskDealMulti 可批处理的任务接口

public interface IScheduleTaskDealMulti<T>  extends IScheduleTaskDeal<T> {/*** 	执行给定的任务数组。因为泛型不支持new 数组，只能传递OBJECT[]* @param tasks 任务数组* @param ownSign 当前环境名称* @return* @throws Exception*/public boolean execute(Object[] tasks,String ownSign) throws Exception;
}