定时器的使用

目录

前言

正文 

1.方法 schedule(TimerTask task, Date time) 的测试

(1)执行任务的时间晚于当前时间(在未来执行)的效果

(2)线程TimerThread不销毁的原因 

(3)使用 public void cancel() 方法实现 TimerThread 线程销毁

(4)执行任务的时间早于当前时间(立刻运行)的效果

(5)在定时器中执行多个 TimerTask 任务 

(6)延时执行 TimerTask 的测试

2.方法 schedule(TimerTask task, long delay, long period)

(1)执行任务的时间晚于当前时间(在未来执行)的效果 

(2)执行任务的时间早于当前时间(立即执行)的效果

(3)延迟执行 TimerTask 的测试 

(4)TimerTask 类中的 cancel() 方法

(5)类 Timer 中的 cancel() 方法 

(6)间隔执行任务的算法

(7)Timer 类中的 cancel() 方法的注意事项 

3.方法 schedule(TimerTask task,long delay) 的测试

4.方法 schedule(TimerTask task,long delay,long period) 的测试。

5.方法 public void scheduleAtFixedRate(TimerTask task, Date firstTime,long period)的测试

(1)测试 schedule 方法任务不延时(Date 类型)

(2)测试 schedule 方法任务不延时(Long 类型)

(3)测试 schedule 方法任务延时(Date 类型)

(4)测试 schedule 方法任务被延时(Long 类型) 

(5)测试 scheduleAtFixedRate 方法任务不延时(Date 类型)

(6)测试 scheduleAtFixedRate 方法任务不延时(Long 类型) 

(7)测试 scheduleAtFixedRate 方法任务延时(Date 类型)

(8)测试 scheduleAtFixedRate 方法任务延时(Long 类型) 

(9)验证 schedule 方法不具有追赶特性 

(10)验证 scheduleAtFixedRate 方法具有追赶性 


 

前言

定时/计划功能在移动开发领域使用较多,比如Android技术,定时功能在Java种主要通过Timer类实现,因为它在内部还是使用多线程的方式进行处理,所以和线程技术还是有非常大的关联。


正文 

 在 JDK 库中 Timer 类主要负责计划任务的功能 ,也就是在指定的时间开始执行某一个任务,Timer类的方法列表如图:

Timer类的主要作用就是设置计划任务,封装任务的类却是 TimerTask,该类的结构图:

 实现了Runnable接口。

因为TaskTimer是一个抽象类,所以执行任务的代码要放入Timer-Task的子类中。

1.方法 schedule(TimerTask task, Date time) 的测试

该方法的作用是在指定日期的执行一次某一任务。

(1)执行任务的时间晚于当前时间(在未来执行)的效果

import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;public class schedule {static class MyTask extends TimerTask{@Overridepublic void run() {System.out.println("任务执行了,时间为:"+System.currentTimeMillis());}}public static void main(String[] args) throws InterruptedException {long nowTime = System.currentTimeMillis();System.out.println("当前时间为:"+nowTime);long scheduleTime = (nowTime+10000L);System.out.println("计划时间为:"+scheduleTime);MyTask task = new MyTask();Timer timer = new Timer();Thread.sleep(1000);timer.schedule(task,new Date(scheduleTime));Thread.sleep(Integer.MAX_VALUE);}}

运行后的效果如图:

10s 之后任务成功执行。任务虽然执行完了,但线程还未销毁,呈红色状态,说明内部还有非守护线程正在执行,从 jvisualvm.exe工具中也得到了证实,程序运行 10s之后,名为 Timer-0 的线程还在运行,效果如图:

下面将介绍这种情况。

(2)线程TimerThread不销毁的原因 

进程不销毁的原因是在创建 Timer 类时启动了一个新的非守护进程,JDK 源代码如下:

    /*** Creates a new timer.  The associated thread does <i>not</i>* {@linkplain Thread#setDaemon run as a daemon}.*/public Timer() {this("Timer-" + serialNumber());}

此构造方法调用的是如下构造方法。

private final TimerThread thread = new TimerThread(queue);public Timer(String name) {thread.setName(name);thread.start();}

查看构造方法可知,创建 一个Timer类时,在内部就启动了 1 个新的线程,用新启动的这个线程去执行计划任务,TimerThread是线程类,源代码如下:

/*** This "helper class" implements the timer's task execution thread, which* waits for tasks on the timer queue, executions them when they fire,* reschedules repeating tasks, and removes cancelled tasks and spent* non-repeating tasks from the queue.*/
class TimerThread extends Thread {

那么这个新启动的线程并不是守护线程了,而且一直在运行。一直在运行的原因是新线程内部有一个死循环,TimeThread.java 类中的 mainLoop() 方法代码如下。

private void mainLoop() {while (true) {try {TimerTask task;boolean taskFired;synchronized(queue) {// Wait for queue to become non-emptywhile (queue.isEmpty() && newTasksMayBeScheduled)queue.wait();if (queue.isEmpty())break; // Queue is empty and will forever remain; die// Queue nonempty; look at first evt and do the right thinglong currentTime, executionTime;task = queue.getMin();synchronized(task.lock) {if (task.state == TimerTask.CANCELLED) {queue.removeMin();continue;  // No action required, poll queue again}currentTime = System.currentTimeMillis();executionTime = task.nextExecutionTime;if (taskFired = (executionTime<=currentTime)) {if (task.period == 0) { // Non-repeating, removequeue.removeMin();task.state = TimerTask.EXECUTED;} else { // Repeating task, reschedulequeue.rescheduleMin(task.period<0 ? currentTime   - task.period: executionTime + task.period);}}}if (!taskFired) // Task hasn't yet fired; waitqueue.wait(executionTime - currentTime);}if (taskFired)  // Task fired; run it, holding no lockstask.run();} catch(InterruptedException e) {}}}

private void mainLoop()方法内部使用 while(true) 死循环一直执行计划任务,并不退出 while(true)死循环,依据源代码的执行流程,除非是满足 if (queue.isEmpty()) 条件,才执行 break 退出 while(true)死循环,退出逻辑的核心源代码如下:

 while (queue.isEmpty() && newTasksMayBeScheduled)queue.wait();if (queue.isEmpty())break; 

上面的源代码逻辑如下:

(1)使用 while 循环对 queue.isEmpty() && newTasksMayBeScheduled 条件进行判断。

(2)当 && 两端都为 true 时,执行 wait() 方法使当前线程被暂停运行,等待被唤醒。

(3)唤醒的时机是执行了 public void schedule(TimeTask task,Date time)方法,说明要执行新的任务了。

(4)唤醒后 while 继续判断 queue.isEmpty() && newTaskMayBeScheduled 条件,如果有新的任务被安排,则 queue.isEmpty() 结果为 false,&&最终结果为是 false,会继续执行下面的 if 语句。

(5)if(queue.isEmpty()) 中的 queue.isEmpty() 结果为 true,说明队列为空,那么执行 break 语句退出 while(true) 死循环。

(6)执行 public void cancel() 方法会使布尔变量 newTaskMayBeScheduled 的值由 true 变成 false。

(7)如果不执行 public void cancel(),变量 newTaskMayBeScheduled 的值就不会是 false,一直呈死循环的状态,进程不销毁就是这个原因,public void cancel() 方法源代码如下。

public void cancel() {synchronized(queue) {thread.newTasksMayBeScheduled = false;queue.clear();queue.notify();  // In case queue was already empty.}}

上面 7 步就是进程不消毁的原因,以及退出死循环 while(true) 的逻辑。 

(3)使用 public void cancel() 方法实现 TimerThread 线程销毁

Timer 类中 public void cancel() 方法的作用是终止此计时器,丢弃当前所有已安排的任务。这不会干扰当前正在执行的任务(如果存在)。一旦终止了计时器,那么它的执行线程也会终止,并且无法根据它安排更多的任务。注意,在此计算器调用的计时器任务的 run() 方法内调用此方法,就可以确保正在执行的任务是此计算器的最后一个任务。虽然可以重复调用此方法,但是第二次和后续调用无效。

根据上面的源代码分析可知,当队列中为空,并且 newTaskMayBeScheduled 值是 false 时,退出 while(true) 死循环,导致 TimerThread 线程结束运行并销毁。

import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;public class Test {static class MyTask extends TimerTask {@Overridepublic void run() {System.out.println("任务执行了,时间为:"+System.currentTimeMillis());}}public static void main(String[] args) throws InterruptedException {long nowTime = System.currentTimeMillis();System.out.println(" 当前时间为:" + nowTime);long scheduleTime = (nowTime + 15000L);System.out.println(" 计划时间为:"+scheduleTime);MyTask task = new MyTask();Timer timer = new Timer();timer.schedule(task,new Date(scheduleTime));Thread.sleep(18000);timer.cancel();Thread.sleep(Integer.MAX_VALUE);}
}

程序运行18秒之后,从 jvisualvm.exe工具中可以看到名称为 Timer-0 的线程 TimerThread被销毁(在已完成的线程中)了,效果如图: 

虽然 TimerThread 线程销毁了,但进程还是呈红色状态,这时因为main 线程一直在执行 Thread.sleep(Integer.MAX_VALUE) 代码,控制台输出如下:

(4)执行任务的时间早于当前时间(立刻运行)的效果

如果执行任务的时间早于当前时间,则立即执行任务。

import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;public class Test {static class MyTask extends TimerTask {@Overridepublic void run() {System.out.println("任务执行了,时间为:"+System.currentTimeMillis());}}public static void main(String[] args) throws InterruptedException {long nowTime = System.currentTimeMillis();System.out.println(" 当前时间为:" + nowTime);long scheduleTime = (nowTime - 5000);System.out.println(" 计划时间为:"+scheduleTime);MyTask task = new MyTask();Timer timer = new Timer();timer.schedule(task,new Date(scheduleTime));}
}

效果如图:

(5)在定时器中执行多个 TimerTask 任务 

可以在定时器中执行多个 TimerTask 任务。 

import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;public class Test {static class MyTask extends TimerTask {@Overridepublic void run() {System.out.println("任务执行了,时间为:"+System.currentTimeMillis());}}public static void main(String[] args) throws InterruptedException {long nowTime = System.currentTimeMillis();System.out.println(" 当前时间为:" + nowTime);long scheduleTime1 = (nowTime + 5000);long scheduleTime2 = (nowTime + 8000);System.out.println(" 计划时间1为:"+scheduleTime1);System.out.println(" 计划时间2为:"+scheduleTime2);MyTask task1 = new MyTask();MyTask task2 = new MyTask();Timer timer = new Timer();timer.schedule(task1,new Date(scheduleTime1));timer.schedule(task2,new Date(scheduleTime2));}
}

程序运行结果如图:

(6)延时执行 TimerTask 的测试

因为TimerTask是以一个队列得到方式一个一个被顺序执行的,所以执行的时间有可能和预期的时间不一致。因为前面的任务有可能消耗的时间较长,所以后面的任务运行的时间也被延后,请看下面的示例:

import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;public class taskLater {static class MyTaskA extends TimerTask {@Overridepublic void run() {try {System.out.println("A begin timer=" + System.currentTimeMillis());Thread.sleep(20000);System.out.println("A   end Timer=" + System.currentTimeMillis());} catch (InterruptedException e) {e.printStackTrace();}}}static class MyTaskB extends TimerTask{@Overridepublic void run() {System.out.println("B begin timer="+System.currentTimeMillis());System.out.println("B   end timer="+System.currentTimeMillis());}}public static void main(String[] args) {long nowTime = System.currentTimeMillis();System.out.println("当前时间为:"+nowTime);long scheduleTime1 = nowTime;long scheduleTime2 = nowTime+5000;System.out.println("计划时间1为:"+scheduleTime1);System.out.println("计划时间2为:"+scheduleTime2);MyTaskA taskA = new MyTaskA();MyTaskB taskB = new MyTaskB();Timer timer = new Timer();timer.schedule(taskA,new Date(scheduleTime1));timer.schedule(taskB,new Date(scheduleTime2));}
}

程序运行结果如图:

在代码中,long scheduleTime2 = now + 5000 原计划是执行任务1 和任务 2 的运行间隔时间为 5 秒,由于 task1 执行任务需要 20 秒,因此 task1 的结束时间就是 task2 的开始时间,task2 不再以 5 秒作为参考, 而是以 20 秒作为参考,究其原理是创建了 1 个Timer 类导致创建了 1 个TimerThread 线程,1 个TimerThread 线程管理 1 个队列,在队列中得按顺序运行任务。

2.方法 schedule(TimerTask task, long delay, long period)

该方法的作用是在指定的日期之后按指定的间隔周期无限循环地执行某一任务。

(1)执行任务的时间晚于当前时间(在未来执行)的效果 


import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;public class timerTest2_period {static class MyTask extends TimerTask{@Overridepublic void run() {System.out.println("任务执行了,时间为:"+System.currentTimeMillis());}}public static void main(String[] args) {long nowTime = System.currentTimeMillis();System.out.println("当前时间为:"+nowTime);long scheduleTime = (nowTime+10000);System.out.println("计划时间为:"+scheduleTime);MyTask task = new MyTask();Timer timer = new Timer();timer.schedule(task,new Date(scheduleTime),4000L);}}

程序运行结果如图:

从运行结果来看,每隔 4 秒运行一次 TimerTask 任务,并且是无限期重复执行任务。

(2)执行任务的时间早于当前时间(立即执行)的效果

如果计划时间早于当前时间,则立即执行任务。

import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;public class Test2 {static class MyTask extends TimerTask {@Overridepublic void run() {System.out.println("任务执行了,时间为:"+System.currentTimeMillis());}}public static void main(String[] args) throws InterruptedException {long nowTime = System.currentTimeMillis();System.out.println(" 当前时间为:" + nowTime);long scheduleTime = (nowTime - 5000);System.out.println(" 计划时间为:"+scheduleTime);MyTask task = new MyTask();Timer timer = new Timer();timer.schedule(task,new Date(scheduleTime),4000L);}
}

程序运行结果如图:

控制台打印的结果是程序运行后立即执行任务,并且每隔 4 秒打印一次。 

(3)延迟执行 TimerTask 的测试 

import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;public class timerTest2_periodLater {static class MyTaskA extends TimerTask{@Overridepublic void run() {try{System.out.println("A begin timer="+System.currentTimeMillis());Thread.sleep(5000);System.out.println("A           end timer="+System.currentTimeMillis());} catch (InterruptedException e) {e.printStackTrace();}}}public static void main(String[] args) {long nowTime = System.currentTimeMillis();System.out.println("当前时间为:  "+nowTime);System.out.println("    计划时间为:  "+nowTime);MyTaskA taskA = new MyTaskA();Timer timer = new Timer();timer.schedule(taskA,new Date(nowTime),3000);}
}

使用代码 timer.schedule(taskA,new Date(nowTime),3000);是让每个任务执行的间隔时间为 3 秒,而运行结果却是 5 秒,这是因为在任务中执行了 Thread.sleep(5000) ,程序运行结果如图所示:

(4)TimerTask 类中的 cancel() 方法

TimerTask 类中的 cancel() 方法的作用是将自身从任务队列中清楚,该方法的源代码如下。 

    public boolean cancel() {synchronized(lock) {boolean result = (state == SCHEDULED);state = CANCELLED;return result;}}

从方法得到代码可以分析出,执行 TimerTask 类中的 cancel() 方法时是将当前 TimerTask 任务得到状态改为 CANCELLED。

测试代码如下:

import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;public class TimerTaskCancelMethod {static class MyTaskA extends TimerTask{@Overridepublic void run() {System.out.println("A run timer="+System.currentTimeMillis());this.cancel();System.out.println("A 任务自己移除自己");}}static class MyTaskB extends TimerTask{@Overridepublic void run() {System.out.println("B run timer="+System.currentTimeMillis());}}public static void main(String[] args) {long nowTime = System.currentTimeMillis();System.out.println("当前时间为:"+nowTime);System.out.println("计划时间为:"+nowTime);MyTaskA task1 = new MyTaskA();MyTaskB task2 = new MyTaskB();Timer timer = new Timer();timer.schedule(task1,new Date(nowTime),4000L);timer.schedule(task2,new Date(nowTime),4000L);}
}

运行结果如下:

TimerTask 类的 cancel() 方法是将自身从任务队列中移除,其他任务不受影响。

(5)类 Timer 中的 cancel() 方法 

和 TimerTask 类中的 cancel() 方法清除自身不同,Timer 类中 cancel() 方法的作用是将任务队列中全部的任务清空,源代码如下。

 public void cancel() {synchronized(queue) {thread.newTasksMayBeScheduled = false;queue.clear();queue.notify();  // In case queue was already empty.}}

创建新的测试用例:

import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;public class TimerCancelMethod {static class MyTaskA extends TimerTask {@Overridepublic void run() {System.out.println("A run timer="+System.currentTimeMillis());}}static class MyTaskB extends TimerTask{@Overridepublic void run() {System.out.println("B run timer="+System.currentTimeMillis());}}public static void main(String[] args) throws InterruptedException {long nowTime = System.currentTimeMillis();System.out.println("当前时间为:"+nowTime);System.out.println("计划时间为:"+nowTime);MyTaskA task1 = new MyTaskA();MyTaskB task2 = new MyTaskB();Timer timer = new Timer();timer.schedule(task1,new Date(nowTime),2000L);timer.schedule(task2,new Date(nowTime),2000L);Thread.sleep(10000);timer.cancel();         //全部任务都取消}
}

程序运行 10 秒后,进程销毁,控制台输出结果如图:

全部任务都被清楚,并且进程被销毁,按钮由红色变成灰色。 

(6)间隔执行任务的算法

当队列中有三个任务 A B C 时,这三个任务执行顺序的算法是每次将最后一个任务放入队列头,再执行队列头中任务的 run() 方法,算法效果如下:

1)起始顺序为 A B C。

2)C A B,将 C  放入 AB 之前。

3)  B C A,将 B 放入 C A之前。

创建新的任务代码如下:

import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;public class NewAlgorithm {static class MyTaskA extends TimerTask {@Overridepublic void run() {System.out.println("A run timer="+System.currentTimeMillis());}}static class MyTaskB extends TimerTask{@Overridepublic void run() {System.out.println("B run timer="+System.currentTimeMillis());}}static class MyTaskC extends TimerTask{@Overridepublic void run() {System.out.println("C run timer="+System.currentTimeMillis());}}public static void main(String[] args) {long nowTime = System.currentTimeMillis();System.out.println("当前时间为:"+nowTime);System.out.println("计划时间为:"+nowTime);MyTaskA taskA = new MyTaskA();MyTaskB taskB = new MyTaskB();MyTaskC taskC = new MyTaskC();Timer timer = new Timer();timer.schedule(taskA,new Date(nowTime),2000L);timer.schedule(taskB,new Date(nowTime),2000L);timer.schedule(taskC,new Date(nowTime),2000L);}
}

运行结果如图:

(7)Timer 类中的 cancel() 方法的注意事项 

Timer() 类中的 cancel() 方法有时不一定会停止计划任务,而是正常执行。

创建新的项目:

import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;public class TimerCancelError {static class MyTaskA extends TimerTask {private int i;public MyTaskA(int i) {super();this.i = i;}@Overridepublic void run() {System.out.println(" 第" + i + "次没有被cancel取消");}}public static void main(String[] args) throws InterruptedException {int i = 0;long nowTime = System.currentTimeMillis();System.out.println("当前时间为:"+nowTime);System.out.println("计划时间为:"+nowTime);while(true){i++;Timer timer = new Timer();MyTaskA taskA = new MyTaskA(i);timer.schedule(taskA,new Date(nowTime));timer.cancel();}}
}

程序运行后代码截图:

因为 Timer 类中的 cancel() 方法有时并没有争抢到队列锁,所以让TimerTask 任务正常执行。 

3.方法 schedule(TimerTask task,long delay) 的测试

该方法的作用是以执行 schedule(TimerTask task,long delay) 方法当前的时间为参考时间,在此时间基础上延迟指定的毫秒数后执行一次 TImerTask 任务。

import java.util.Timer;
import java.util.TimerTask;public class timerTest3 {static class MyTask extends TimerTask{@Overridepublic void run() {System.out.println("运行了!时间为"+System.currentTimeMillis());}}public static void main(String[] args) {MyTask task = new MyTask();Timer timer = new Timer();System.out.println("当前时间为:"+System.currentTimeMillis());timer.schedule(task,7000L);}
}

程序运行结果如图: 

 任务被延迟 7 秒执行了。

4.方法 schedule(TimerTask task,long delay,long period) 的测试。

该方法的作用是以执行 schedule(TimerTask task,long delay,long period) 方法当前的时间为参考时间,在此时间的基础上延迟指定的毫秒数,再以某一间隔时间无限次数地执行某一任务。

import java.util.Timer;
import java.util.TimerTask;public class timerTest3 {static class MyTask extends TimerTask{@Overridepublic void run() {System.out.println("运行了!时间为"+System.currentTimeMillis());}}public static void main(String[] args) {MyTask task = new MyTask();Timer timer = new Timer();System.out.println("当前时间为:"+System.currentTimeMillis());timer.schedule(task,3000L,5000);}
}

程序运行结果如图:

凡是使用方法中带有 period 参数的,都是无限循环执行 TimerTask 中的任务。

5.方法 public void scheduleAtFixedRate(TimerTask task, Date firstTime,long period)的测试

schedule 方法和 scheduleAtFixedRate 方法的主要区别在于有没有追赶特性

(1)测试 schedule 方法任务不延时(Date 类型)

创建项目,测试代码如下:

import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;public class timerTest5 {static class MyTask extends TimerTask {@Overridepublic void run() {try {System.out.println("begin timer="+System.currentTimeMillis());Thread.sleep(1000);System.out.println("    end timer="+System.currentTimeMillis());} catch (InterruptedException e) {e.printStackTrace();}}}public static void main(String[] args) {MyTask task = new MyTask();long nowTime = System.currentTimeMillis();Timer timer = new Timer();timer.schedule(task,new Date(nowTime),3000);}
}

运行结果如图:

控制台打印结果证明,在不延时的情况下,如果执行任务的时间没有被延时,则下一次执行任务的开始时间是上一次任务的开始时间加上 period 时间。

所谓的 “不延时” 是指执行任务的时间小于 period 间隔时间。

(2)测试 schedule 方法任务不延时(Long 类型)

import java.util.Timer;
import java.util.TimerTask;public class Test2 {static class MyTask extends TimerTask {@Overridepublic void run() {try {System.out.println("begin timer="+System.currentTimeMillis());Thread.sleep(1000);System.out.println("    end timer="+System.currentTimeMillis());} catch (InterruptedException e) {e.printStackTrace();}}}public static void main(String[] args) {MyTask task = new MyTask();System.out.println(" 当前时间:"+System.currentTimeMillis());Timer timer = new Timer();timer.schedule(task,3000L,4000L);}
}

运行结果如图:

控制台打印的结果证明,在不延时的情况下,如果执行任务的时间没有被延时,则第一次执行任务的时间是任务快开始时间加上延时时间,接下来执行任务的时间是上一次任务的开始时间加上 period 时间。 

(3)测试 schedule 方法任务延时(Date 类型)

创建测试用例:

import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;public class timerTest5 {static class MyTask extends TimerTask {@Overridepublic void run() {try {System.out.println("begin timer="+System.currentTimeMillis());Thread.sleep(5000);System.out.println("    end timer="+System.currentTimeMillis());} catch (InterruptedException e) {e.printStackTrace();}}}public static void main(String[] args) {MyTask task = new MyTask();long nowTime = System.currentTimeMillis();Timer timer = new Timer();timer.schedule(task,new Date(nowTime),2000);}
}

运行结果如图:

从控制台打印结果来看,在延时的情况下,如果执行任务的时间被延时,那么下一次任务的执行时间参考的是上一次任务 "结束" 的时间。 

(4)测试 schedule 方法任务被延时(Long 类型) 

测试用例如下:

import java.util.Timer;
import java.util.TimerTask;public class Test2 {static class MyTask extends TimerTask {@Overridepublic void run() {try {System.out.println("begin timer="+System.currentTimeMillis());Thread.sleep(5000);System.out.println("    end timer="+System.currentTimeMillis());} catch (InterruptedException e) {e.printStackTrace();}}}public static void main(String[] args) {MyTask task = new MyTask();System.out.println(" 当前时间:"+System.currentTimeMillis());Timer timer = new Timer();timer.schedule(task,3000L,2000L);}
}

运行结果如图:

从控制台打印结果来看,在延时的情况下,如果执行任务的时间被延时,那么下一次任务的执行时间参考的是上一次任务 "结束" 的时间。 

(5)测试 scheduleAtFixedRate 方法任务不延时(Date 类型)

创建新的测试用例,本次测试使用 scheduleAtFixedRate 作为测试。 

import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;public class timerTest5 {static class MyTask extends TimerTask {@Overridepublic void run() {try {System.out.println("begin timer="+System.currentTimeMillis());Thread.sleep(1000);System.out.println("    end timer="+System.currentTimeMillis());} catch (InterruptedException e) {e.printStackTrace();}}}public static void main(String[] args) {MyTask task = new MyTask();long nowTime = System.currentTimeMillis();Timer timer = new Timer();timer.scheduleAtFixedRate(task,new Date(nowTime),3000);}
}

控制台打印的结果证明,在不延时的情况下,如果执行任务的时间没有被延时,则下一次执行任务的时间是上一次任务的开始时间加上 period 时间。 

(6)测试 scheduleAtFixedRate 方法任务不延时(Long 类型) 

创建测试用例: 

import java.util.Timer;
import java.util.TimerTask;public class Test2 {static class MyTask extends TimerTask {@Overridepublic void run() {try {System.out.println("begin timer="+System.currentTimeMillis());Thread.sleep(1000);System.out.println("    end timer="+System.currentTimeMillis());} catch (InterruptedException e) {e.printStackTrace();}}}public static void main(String[] args) {MyTask task = new MyTask();System.out.println(" 当前时间:"+System.currentTimeMillis());Timer timer = new Timer();timer.scheduleAtFixedRate(task,3000L,4000L);}
}

运行结果如图:

控制台打印的结果证明,在不延时的情况下,如果执行任务的时间没有被延时,则下一次执行任务的时间是上一次任务的开始时间加上 period 时间。  

(7)测试 scheduleAtFixedRate 方法任务延时(Date 类型)

创建测试用例:


import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;public class timerTest5 {static class MyTask extends TimerTask {@Overridepublic void run() {try {System.out.println("begin timer="+System.currentTimeMillis());Thread.sleep(5000);System.out.println("    end timer="+System.currentTimeMillis());} catch (InterruptedException e) {e.printStackTrace();}}}public static void main(String[] args) {MyTask task = new MyTask();long nowTime = System.currentTimeMillis();Timer timer = new Timer();timer.scheduleAtFixedRate(task,new Date(nowTime),2000);}
}

运行结果如图:

 

从控制台打印结果来看,在延时的情况下,如果执行任务的时间被延时,那么下一次任务的执行时间参考的是上一次任务 "结束" 的时间。  

(8)测试 scheduleAtFixedRate 方法任务延时(Long 类型) 

创建测试用例:

import java.util.Timer;
import java.util.TimerTask;public class Test2 {static class MyTask extends TimerTask {@Overridepublic void run() {try {System.out.println("begin timer="+System.currentTimeMillis());Thread.sleep(5000);System.out.println("    end timer="+System.currentTimeMillis());} catch (InterruptedException e) {e.printStackTrace();}}}public static void main(String[] args) {MyTask task = new MyTask();System.out.println(" 当前时间:"+System.currentTimeMillis());Timer timer = new Timer();timer.scheduleAtFixedRate(task,3000L,2000L);}
}

运行结果如图:

 

从控制台打印结果来看,在延时的情况下,如果执行任务的时间被延时,那么下一次任务的执行时间参考的是上一次任务 "结束" 的时间。 

从上面 8 个运行结果来看,schedule 方法和 scheduleAtFixedRate 方法在运行效果上并没有非常明显的区别,那它们之间到底有什么区别呢,那就是追赶特性。

(9)验证 schedule 方法不具有追赶特性 

创建测试用例:

import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;public class Test9 {static class MyTask extends TimerTask{@Overridepublic void run() {System.out.println("begin timer="+System.currentTimeMillis());System.out.println("    end timer="+System.currentTimeMillis());}}public static void main(String[] args) {MyTask task = new MyTask();long nowTime = System.currentTimeMillis();System.out.println("现在执行时间:"+nowTime);long runTime = nowTime - 20000;System.out.println("计划执行时间:"+runTime);Timer timer = new Timer();timer.schedule(task,new Date(runTime),2000);}
}

运行结果如图:

 

从运行结果上来看,“1700620549103” 到 ”1700620529103“ 的时间所对应的任务被取消掉,不执行了,这就是任务不追赶。

(10)验证 scheduleAtFixedRate 方法具有追赶性 

import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;public class Test9 {static class MyTask extends TimerTask{@Overridepublic void run() {System.out.println("begin timer="+System.currentTimeMillis());System.out.println("    end timer="+System.currentTimeMillis());}}public static void main(String[] args) {MyTask task = new MyTask();long nowTime = System.currentTimeMillis();System.out.println("现在执行时间:"+nowTime);long runTime = nowTime - 20000;System.out.println("计划执行时间:"+runTime);Timer timer = new Timer();timer.scheduleAtFixedRate(task,new Date(runTime),2000);}
}

运行结果如图:

11次(开始1次加上{20000/2000}能运行的10次总共11次打印任务时间 “1700621411899” 都是曾经流逝时间的任务追赶,也就是将曾经没有执行的任务追加进行执行,将 20 秒之内执行任务的次数打印完,再每间隔 2 秒执行一次任务。

将两个时间段内的时间所对应的任务被 “弥补” 地执行,也就是在指定时间段内的运行次数必须要运行完整,这就是任务追赶特性

 

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.hqwc.cn/news/205557.html

如若内容造成侵权/违法违规/事实不符,请联系编程知识网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

阿里云高效计划学生和老师免费代金券申请认证方法

阿里云高校计划学生和教师均可参与&#xff0c;完成学生认证和教师验证后学生可以免费领取300元无门槛代金券和3折优惠折扣&#xff0c;适用于云服务器等全量公共云产品&#xff0c;订单原价金额封顶5000元/年&#xff0c;阿里云百科aliyunbaike.com分享阿里云高校计划入口及学…

不是说人工智能是风口吗,那为什么工作还那么难找?

最近确实有很多媒体、机构渲染人工智能可以拿高薪&#xff0c;这在行业内也是事实&#xff0c;但前提是你有足够的竞争力&#xff0c;真的懂人工智能。 首先&#xff0c;人工智能岗位技能要求高&#xff0c;人工智能是一个涵盖了多个学科领域的综合性学科&#xff0c;包括数学、…

LiteOS同步实验(实现生产者-消费者问题)

效果如下图&#xff1a; 给大家解释一下上述效果&#xff1a;在左侧&#xff08;顶格&#xff09;的是生产者&#xff08;Producer&#xff09;&#xff1b;在右侧&#xff08;空格&#xff09;的是消费者&#xff08;Consumer&#xff09;。生产者有1个&#xff0c;代号为“0”…

Scala如何写一个通用的游戏数据爬虫程序

以前想要获取一些网站数据的时候&#xff0c;都是通过人工手动复制粘贴&#xff0c;这样的效率及其低下。数据少无所谓&#xff0c;如果需要采集大量数据&#xff0c;手动就显得乏力了。半夜睡不着&#xff0c;爬起来写一段有关游戏商品数据的爬虫通用模板&#xff0c;希望能帮…

Git——感谢尚硅谷官方文档

Git——尚硅谷学习笔记 第1章 Git 概述1.1 何为版本控制1.2 为什么需要版本控制1.3 版本控制工具1.4 Git 简史1.5 Git 工作机制1.6 Git 和代码托管中心 第2章 Git 安装第 3 章 Git 常用命令3.1 设置用户签名3.2 初始化本地库3.3 查看本地库状态3.4 添加暂存区3.4.1 将工作区的文…

JavaDS —— 初识集合框架 + 时间/空间复杂度

目录 1. 初识集合框架 1.1 集合框架的初识 1.2 什么是数据结构&#xff1f; 2. 时间与空间复杂度 2.1 时间复杂度 2.2 大O的渐进表示法 2.3 常见时间复杂度计算举例 2.4 空间复杂度 1. 初识集合框架 1.1 集合框架的初识 什么叫集合&#xff1f;什么叫框架&#xff1f;什么又叫集…

React函数组件渲染两次

渲染两次是因为react默认开启了严格模式 React.StrictMode标签作用&#xff1a; 1、识别不安全的生命周期 2、关于使用过时字符串 ref API 的警告 3、关于使用废弃的 findDOMNode 方法的警告 4、检测意外的副作用 5、检测过时的 context API 注释掉React.StrictMode即为关闭严…

Vue3实现粒子动态背景

官网&#xff1a; https://particles.js.org/ npm&#xff1a; https://www.npmjs.com/package/particles.vue3 安装 pnpm add particles.vue3 pnpm add tsparticles-slim 注册 main.js import { createApp } from vue import type { App } from vue import globleApp f…

Spark---转换算子、行动算子、持久化算子

一、转换算子和行动算子 1、Transformations转换算子 1&#xff09;、概念 Transformations类算子是一类算子&#xff08;函数&#xff09;叫做转换算子&#xff0c;如map、flatMap、reduceByKey等。Transformations算子是延迟执行&#xff0c;也叫懒加载执行。 2)、Transf…

Java Stream中的API你都用过了吗?

公众号「架构成长指南」&#xff0c;专注于生产实践、云原生、分布式系统、大数据技术分享。 在本教程中&#xff0c;您将通过大量示例来学习 Java 8 Stream API。 Java 在 Java 8 中提供了一个新的附加包&#xff0c;称为 java.util.stream。该包由类、接口和枚举组成&#x…

Maven中常用命令以及idea中使用maven指南

文章目录 Maven 常用命令compiletestcleanpackageinstallMaven 指令的生命周期maven 的概念模型 idea 开发maven 项目idea 的maven 配置idea 中创建一个maven 的web 工程在pom.xml 文件添加坐标坐标的来源方式依赖范围编写servlet maven 工程运行调试 Maven 常用命令 compile …

腾讯云服务器99元一年?假的,阿里云是99元

腾讯云服务器99元一年是真的吗&#xff1f;假的&#xff0c;不用99元&#xff0c;只要88元即可购买一台2核2G3M带宽的轻量应用服务器&#xff0c;99元太多了&#xff0c;88元就够了&#xff0c;腾讯云百科活动 txybk.com/go/txy 活动打开如下图&#xff1a; 腾讯云服务器价格 腾…