JDK Timer & TimerTask

2022-10-29 20:03:34

Timer & TimerTask

@(Base)[JDK, Timer, TimerTask]

Timer schedule(动词) task在后台执行。这个Task可能是只执行一次的task，也可能是按照一定规律执行的task。这也是JDK1.3提供的一个非常老的工具类

对于每一个维持schedule的Timer对象来说，内部都只有一个线程顺序执行所有的task。所以每一个客户端提交的task需要尽可能快的完成。如果中间有个线程执行时间非常久，就会hogs起线程，然后面的线程都delay，这样会导致后续处理都很凌乱，让他们全部弄成一团在执行。
当最后持有Timer引用的Object gc掉之后，并且所有的任务已经执行完了之后，timer的execution thread会gracefully终止（然后被垃圾回收）。这个时间可以变得无限长。这个execution线程并不是daemon的。所以他可以让你的application无法终止。如果调用方想要尽快终止程序，可以调用caller的cancel方法。
如果timer的execute的线程异常终止，例如，当他的stop方法被调用的时候，当你再提交一个task进来的时候，就会抛出IllegalStateExcetpion，因为Timer的cancel方法已经被调用了。
这个类是线程安全的。
这个class通过Object.wait方法来调度任务。

注意： java 1.5 引入的并发包，中有一个ScheduledThreadPoolExecutor，是一个线程池，可以提供固定比率，或者时长的task。

Timer & TimerTask
Binary Heap
LifeCycle

Binary Heap

二叉堆是一种经过排序的完全二叉树，其中任一非终端节点的数据值均不大于（或不小于）其左孩子和右孩子节点的值。 —— *

最大堆和最小堆是二叉堆的两种形式。
最大堆：根结点的键值是所有堆结点键值中最大者。
最小堆：根结点的键值是所有堆结点键值中最小者。

最小堆，就是用于实现优先级队列的。

对于节点N，那么他的两个子节点就是2n, 2n+1，n为数组位置

Insert

首先插入尾部，然后一直与index/2，比较交换。

6 --> [6]

9 --> [6,9]

4 --> [6,9,4] --> 4 < arr[3/2-1] --> change(arr[0], arr[2]) --> [4,9,6]

7 --> [4,9,6] --> 7 < arr[4/2-1] --> change(arr[1], arr[3]) --> [4,7,6,9]

5 --> [4,7,6,9,5] --> 5 < arr[5/2-1] --> change[arr[1], arr[4]] --> [4,5,6,9,7]

1 --> [4,5,6,9,7,1] --> 1 < arr[3-1] --> change[arr[2], arr[5]]

每次插入完成之后总能保证第一个是最小的，这个交换操称为fixUp，或者叫ShiftUp。

DELETE MIN

交换队头和队尾，然后删除队尾，然后比较index2, index+2 交换到最小。

[1,5,4,9,7,6] --> [6,5,4,9,7,1] --> [6,5,4,9,7] --> [4,5,6,9,7]

这个操作成为fixDown，或者ShiftDown。

PERFORMANCE

log(n) for add,removeMin,rescheduleMin.

constant time performance for the getMin operation.

LifeCycle

Constructor

新建TimerThread调度程序。执行mainLoop()

public void run() {

   try { mainLoop(); }

   finally { clean(); }

}

MainLoop

等待在队列上，有值唤醒后取出min操作.

while (true) {

   sync(queue) {

      while (queue.isEmpty()) { // avoid furious weak up

         queue.wait();          // point 1

      }

      task = queue.getMain();

      sync (task) { // avoid out-side modify // point 2

          // do some cancel check

          if (taskFired = (executionTime <= currentTime)) {

             queue.rescheduleMin(); // or queue.removeMin();

          }

      }

      if (!taskFired) { // point3

         queue.wait(executionTime)

      }

   }

   if (taskFired) { // point4

       task.run()

   }

}

这段小代码还是很精悍。

Point 1: 利用queue对象的wait/notify做了通知模型，当有新任务的时候就会唤醒
Point 2: 锁定task对象，避免task对象的内部状态被别人更改，当确定完状态之后，外部更改也就无效了，并且只是改状态的时候加锁
Point 3: 当前task的执行时间还不到的时候，挂在queue对象上睡，为什么挂在queue对象上睡呢，这一点很重要，当有新任务进来的时候可以响应到。
Point 4: 唤醒之后，如果还不够时间，就进入下一次循环。否则如果够了的话就执行。

schedule

sync (queue) {

   sync(task) {

      // change state and nextTime

   }

   queue.add(task)

   if (queue.getMin() == task) {

      queue.notify();

   }

}

cancel Timer

synchronized(queue) {

    thread.newTasksMayBeScheduled = false;

    queue.clear();

    queue.notify();  // In case queue was already empty.

}

cancel one Time Task

sync(this.lock) {

   this.state = CANCEL;

}

purge

清除所有已经被cancel的task，一般小程序都不需要使用。

sync (queue) {

   for (item in queue) {

       queue.remove(item); // change current with the last

   }

   reindex();

}

完

码农公寓