一、参考文章:
二、Timer问题:
- 1、如何开启任务;
- 2、如何停止正在运行的任务;
- 3、线程间通信;
- 4、Timer有什么缺陷;
三、demo:
private Timer mTimer;
public void timerStart() {
TimerTask timerTask = new TimerTask() {
@Override
public void run() {
LogUtils.log(getClass(), "timerTask");
}
};
mTimer = new Timer();
mTimer.schedule(timerTask, 0, 500);
}
public void timerCancel() {
mTimer.cancel();
}
四、Timer任务开启:
4.1 Timer构造函数:
public class Timer {
private final TaskQueue queue = new TaskQueue();
private final TimerThread thread = new TimerThread(queue);
/**
* 1. Timer初始化时, 创建一个final类型的TaskQueue和TimerThread;
* 2. TimerThread持有TaskQueue的引用, 然后直接调用thread.start方法, 目前猜测可能
* 用到了生产者-消费者模式, 通过TaskQueue.add唤醒当前TimerThread;
*/
public Timer() {
this("Timer-" + serialNumber());
}
public Timer(String name) {
thread.setName(name);
/**
* 开启任务线程, start方法会触发其内部的run方法执行, 这里也就是说一旦初始化
* Timer, 就会开启任务线程;
*/
thread.start(); 模块<4.2>
}
}
class TaskQueue {
void rescheduleMin(long newTime) {
queue[1].nextExecutionTime = newTime;
fixDown(1);
}
}
4.2 TimerThread.run:
class TimerThread extends Thread {
public void run() {
try {
mainLoop();
} finally {
synchronized(queue) {
newTasksMayBeScheduled = false;
queue.clear();
}
}
}
private void mainLoop() {
/**
* 采用while-true的方式, 后续分析要重点关注如何退出while-true;<TODO>
*/
while (true) {
TimerTask task;
boolean taskFired;
/**
* 这里的synchronized是为了<//2--->>的queue.wait使用;
*/
synchronized(queue) {
/**
* 1. newTasksMayBeScheduled表示当前Timer是否可用, 默认true表示可用;
* 2. 如果queue为空, 且Timer可用, 则进入<//2--->>挂起当前线程, 并且释放锁;
*/
//1--->
while (queue.isEmpty() && newTasksMayBeScheduled)
//2---> /**
// * 如果当前没有要执行的任务, 则线程在这里被挂起;
// */
queue.wait();
/**
* 执行if内的break需要以下两种条件:
* 1. queue.isEmpty() == true;
* 2. newTasksMayBeSchedule == false;
*/
//3--->
if (queue.isEmpty())
break;
long currentTime, executionTime;
/**
* 执行到这里说明当前TaskQueue不为empty, 从TaskQueue中取出TimerTask;
*/
task = queue.getMin();
synchronized(task.lock) {
// 如果当前任务已经被取消, 则从TaskQueue中移除当前TimerTask;
if (task.state == TimerTask.CANCELLED) {
queue.removeMin();
continue;
}
currentTime = System.currentTimeMillis();
executionTime = task.nextExecutionTime;
/**
* 结合模块<五>可知, executionTime为初始化TimerTask时指定的执行时间:
* 1. 如果executionTime > currentTime即TimerTask需要延时处理, taskFired = false,
* 跳转至<//4--->>进入阻塞状态;
* 2. 如果executionTime ≤ currentTime即TimerTask不需要延时处理, taskFired = true,
* 跳转至<//5--->>执行run方法;
*/
if (taskFired = (executionTime<=currentTime)) {
/**
* period相当于定时器的作用, 每隔period时间执行一次run方法; 分两种情况:
* 1. period > 0, 每隔period时间通过rescheduleMin刷新任务下一次的执行时间点;
* 2. period = 0, task执行完之后, 从queue中移除, 即TimerTask.run只会执行一次;
*/
if (task.period == 0) { // Non-repeating, remove
queue.removeMin();
task.state = TimerTask.EXECUTED;
} else { // Repeating task, reschedule
queue.rescheduleMin(
task.period<0 ? currentTime - task.period
: executionTime + task.period);
}
}
}
//4--->
if (!taskFired)
/**
* 当前线程被挂起executionTime - currentTime时间之后被唤醒继续向下执行;
*/
queue.wait(executionTime - currentTime);
}
//5--->
if (taskFired)
/**
* 1. 初始化Timer时, 会初始化一个final类型的TimerThread, 一个Timer有且仅有一个
* TimerThread, 所以多个任务在这里进行串行执行, 这里就会有一个弊端, 模块<7>
* 使用demo进行说明;
* 2. 当前run方法执行完成以后, 再次执行while(true)尝试用queue中取出task执行;
*/
task.run();
}
}
}
五、Timer任务执行:
public class Timer {
public void schedule(TimerTask task, long delay, long period) {
sched(task, System.currentTimeMillis()+delay, -period);
}
private void sched(TimerTask task, long time, long period) {
if (Math.abs(period) > (Long.MAX_VALUE >> 1))
period >>= 1;
synchronized(queue) {
/**
* thread.newTasksMayBeScheduled默认为true, 如果thread.newTasksMayBeScheduled
* 为false(即模块<6>调用Timer.cancel方法), 再次调用Timer.schedule方法, 会抛出此异常;
*/
if (!thread.newTasksMayBeScheduled)
throw new IllegalStateException("Timer already cancelled.");
/**
* 对TimerTask进行初始化操作, state默认为SCHEDULED;
*/
synchronized(task.lock) {
if (task.state != TimerTask.VIRGIN)
throw new IllegalStateException("Task already scheduled or cancelled");
task.nextExecutionTime = time;
task.period = period;
task.state = TimerTask.SCHEDULED;
}
queue.add(task);
if (queue.getMin() == task)
queue.notify();
}
}
class TaskQueue {
void add(TimerTask task) {
if (size + 1 == queue.length)
queue = Arrays.copyOf(queue, 2*queue.length);
queue[++size] = task;
fixUp(size);
}
TimerTask getMin() {
return queue[1];
}
}
}
六、任务取消:
public void cancel() {
/**
* 这里用的锁对象与模块<4.2>run和模块<五>是同一个锁对象, 所以取消当前正在执行的任务一定是在
* 当前任务执行完成之后, 或者在schedule完成之后才会执行;
*/
synchronized(queue) {
/**
* 1. 调用cancel之后, newTasksMayBeScheduled = false, 响应模块<五>的schedule方法;
* 2. 调用queue.clear()响应模块<4.2>的<//3--->>处由于queue.isEmpty()且
* newTasksMayBeScheduled = false触发break的执行导致跳出当前while(true);
* 3. queue.notify是为了唤醒模块<4.2>当queue为空时, 通过queue.wait方式被挂起的线程,
* 此时线程被唤醒之后, 再次执行while(true)从而退出while(true)循环;
*/
thread.newTasksMayBeScheduled = false;
queue.clear();
queue.notify(); // In case queue was already empty.
}
}
七、反应模块<4.2>_<//5--->>的一个弊端代码:
public class TimerTest {
private static long start;
public static void timerTest() {
TimerTask task1 = new TimerTask() {
@Override
public void run() {
LogUtils.log(getClass(), "task1 invoked, " + (System.currentTimeMillis() - start));
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
TimerTask task2 = new TimerTask() {
@Override
public void run() {
LogUtils.log(getClass(), "task2 invoked, " + (System.currentTimeMillis() - start));
}
};
Timer timer = new Timer();
start = System.currentTimeMillis();
timer.schedule(task1, 1000);
timer.schedule(task2, 3000);
}
}
- 这段代码取自张鸿洋的文章;
打印结果如下:
05-06 19:58:06.286 4582-4648/com.test V/AndroidTest: ->task1 invoked, 1000
05-06 19:58:09.286 4582-4648/com.test V/AndroidTest: ->task2 invoked, 4001
为何会是这样一种结果?
模块<4.2>的<//5--->>部分说明了Timer内部只有一个线程, 所以通过schedule方式添加的TimerTask是以串行的方式进行, 这就导致task2必须要在task1执行完成以后才能执行, 而task1执行耗时包括delay(1000) + sleep(3000) = time(4000)
因此如果使用Timer连续执行多个task, 后面每个task执行的时间很可能会不准确;
- 弊端的原因是因为每次提交任务之后, 任务是以串行的方式在TimerThread内部执行,
而如果后继Task的执行启动时间小于前继Task的执行(启动时间+执行时间), 则后继
任务的执行将会被推迟;
八、Timer如何保证多任务串行的方式执行:
8.1 Timer.schedule与TimerThread.run:
class TimerThread extends Thread {
private void mainLoop() {
while (true) {
synchronized(queue) {
while (queue.isEmpty() && newTasksMayBeScheduled)
queue.wait();
}
}
if (taskFired)
task.run();
}
}
public class Timer{
public void schedule(TimerTask task, long delay, long period) {
sched(task, System.currentTimeMillis()+delay, -period);
}
private void sched(TimerTask task, long time, long period) {
synchronized(queue) {
queue.add(task);
if (queue.getMin() == task)
queue.notify();
}
}
}
- 1、上面只列了代码片段, queue为final类型, mainLoop(Thread_1)和schedule(Thread_2)可以认为是消费者--生产者模式;
- 2、mainLoop中如果queue.isEmpty == true, 则释放锁并挂起当前线程, 然后sched所处线程尝试获取锁, 添加task然后notify唤醒线程Thread_1;
- 3、如果queue.isEmpty == false, 则Thread_1持有锁, Thread_2 执行sched时被挂起, 直到 Thread_1 执行完task.run之后才会释放锁, 然后Thread_2尝试获取锁像queue中添加Task;
- 4、所以Task能被成功添加到queue中一定是满足queue.isEmpty == true 或者 Thread_1 执行task.run结束;
- 5、所以Task(N)的实际启动时间 == Max(Task(N)启动时间, Task(N-1)启动时间 + Task(N - 1)执行时间);
