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

最新推荐文章于 2022-09-17 10:44:02 发布

点滴记录，是前进的脚步

最新推荐文章于 2022-09-17 10:44:02 发布

阅读量588

点赞数

CC 4.0 BY-SA版权

本文链接：https://blog.youkuaiyun.com/u010287873/article/details/80053628

本文介绍Java中定时器Timer的工作原理，包括其构造方法、线程启动后的run方法及调度方法等。同时，还介绍了TBschedule分布式定时任务调度框架，以及其提供的三种业务接口。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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;
}