Timer定时器

// 简介
一个完整定时任务需要由Timer、TimerTask两个类来配合完成。
Timer：一种工具，线程用其安排以后在后台线程中执行的任务。可安排任务执行一次，或者定期重复执行。
TimerTask：Timer 安排为一次执行或重复执行的任务，可以理解为一个抽象类，它的子类代表一个可以被Timer计划的任务。


// timer类
在工具类Timer中，提供了四个构造方法，每个构造方法都启动了计时器线程，同时Timer类可以保证多个线程可以共享单个Timer
对象而无需进行外部同步，所以Timer类是线程安全的。但是由于每一个Timer对象对应的是单个后台线程，用于顺序执行所有的计
时器任务，一般情况下我们的线程任务执行所消耗的时间应该非常短，但是由于特殊情况导致某个定时器任务执行的时间太长，那
么他就会“独占”计时器的任务执行线程，其后的所有线程都必须等待它执行完，这就会延迟后续任务的执行，使这些任务堆积在
一起。

Timer提供了schedule方法，该方法有多种重载方式来适应不同的情况，如下：
schedule(TimerTask task, Date time)：安排在指定的时间执行指定的任务。
schedule(TimerTask task, Date firstTime, long period) ：安排指定的任务在指定的时间开始进行重复的固定延迟执行。
schedule(TimerTask task, long delay) ：安排在指定延迟后执行指定的任务。
schedule(TimerTask task, long delay, long period) ：安排指定的任务从指定的延迟后开始进行重复的固定延迟执行。
同时也重载了scheduleAtFixedRate方法，scheduleAtFixedRate方法与schedule相同，只不过他们的侧重点不同。
scheduleAtFixedRate(TimerTask task, Date firstTime, long period)：安排指定的任务在指定的时间开始进行重复的固定速率执行。
scheduleAtFixedRate(TimerTask task, long delay, long period)：安排指定的任务在指定的延迟后开始进行重复的固定速率执行

// TimerTask
TimerTask类是一个抽象类，由Timer 安排为一次执行或重复执行的任务。它有一个抽象方法run()方法，该方法用于执行相应计时器任务
要执行的操作。因此每一个具体的任务类都必须继承TimerTask，然后重写run()方法。
另外它还有两个非抽象的方法：
      boolean cancel()：取消此计时器任务。
      long scheduledExecutionTime()：返回此任务最近实际执行的安排执行时间。

  

1、在延迟指定时间后以指定的间隔时间循环执行定时任务

package demo1;

import java.util.Date;
import java.util.TimerTask;

public class TimerTaskDemo1 extends TimerTask{

	@Override
	public void run() {
		Date date = new Date(this.scheduledExecutionTime());
		System.out.println("本次执行该线程的时间为："+date);
	}

}

package demo1;

import java.util.Timer;

public class TimerDemo1 {
	Timer timer;
	
	public TimerDemo1(){
		timer = new Timer();
		timer.schedule(new TimerTaskDemo1(), 1000, 2000);
	}
}

package demo1;

public class TestDemo1 {
	public static void main(String[] args) {
		new TimerDemo1();
	}
}

2、指定延迟时间执行定时任务

package demo2;

import java.util.TimerTask;

public class TimerTaskDemo2 extends TimerTask{

	@Override
	public void run() {
		System.out.println("时间到了");
	}

}

package demo2;

import java.util.Timer;

public class TimerDemo2 {
	Timer timer;
	public TimerDemo2(int time){
		timer = new Timer();
		timer.schedule(new TimerTaskDemo2(), time * 1000);
	}
}

package demo2;

public class TestDemo2 {
	public static void main(String[] args) {
		System.out.println("倒计时开始");
		new TimerDemo2(5);
	}
}

3、在指定时间执行定时任务

package demo3;

import java.util.TimerTask;

public class TimerTaskDemo3 extends TimerTask {

	@Override
	public void run() {
		System.out.println("指定时间执行线程任务");
	}
	
}

package demo3;

import java.util.Calendar;
import java.util.Date;
import java.util.Timer;

public class TimerDemo3 {
	Timer timer;
	
	public TimerDemo3(){
		Date time = getTime();
		System.out.println("指定时间time="+time);
		timer = new Timer();
		timer.schedule(new TimerTaskDemo3(), time);
	}
	
	
	public Date getTime(){
		Calendar calendar = Calendar.getInstance();
		calendar.set(Calendar.HOUR_OF_DAY, 16);
		calendar.set(Calendar.MINUTE, 31);
		calendar.set(Calendar.SECOND, 00);
		Date time = calendar.getTime();
		return time;
		
	}
}

package demo3;

public class TimerTest3 {
	public static void main(String[] args) {
		new TimerDemo3();
	}
}

// 注：当时间到达16:31:00时就会执行该线程任务，当然大于该时间也会执行

schedule VS. scheduleAtFixedRate

1、schedule(TimerTask task, Date time)、schedule(TimerTask task, long delay)
      对于这两个方法而言，如果指定的计划执行时间scheduledExecutionTime<= systemCurrentTime，则task会被立即执行。scheduledExecutionTime
  不会因为某一个task的过度执行而改变。
2、schedule(TimerTask task, Date firstTime, long period)、schedule(TimerTask task, long delay, long period)
      这两个方法与上面两个就有点儿不同的，Timer的计时器任务会因为前一个任务执行时间较长而延时。在这两个方法中，每一次执行的task的计
  划时间会随着前一个task的实际时间而发生改变，也就是scheduledExecutionTime(n+1)=realExecutionTime(n)+periodTime。也就是说如果第n个task
  由于某种情况导致这次的执行时间过程，最后导致systemCurrentTime>= scheduledExecutionTime(n+1)，这是第n+1个task并不会因为到时了而执行，
  他会等待第n个task执行完之后再执行，那么这样势必会导致n+2个的执行实现scheduledExecutionTime发生改变，即scheduledExecutionTime(n+2) =
  realExecutionTime(n+1)+periodTime。所以这两个方法更加注重保存间隔时间的稳定。
3、scheduleAtFixedRate(TimerTask task, Date firstTime, long period)、scheduleAtFixedRate(TimerTask task, long delay, long period)
      scheduleAtFixedRate与schedule方法的侧重点不同，schedule方法侧重保存间隔时间的稳定，而scheduleAtFixedRate方法更加侧重于
  保持执行频率的稳定。原因如下。在schedule方法中会因为前一个任务的延迟而导致其后面的定时任务延时，而scheduleAtFixedRate
  方法则不会，如果第n个task执行时间过长导致systemCurrentTime>= scheduledExecutionTime(n+1)，则不会做任何等待他会立即执行第n+1个
  task，所以scheduleAtFixedRate方法执行时间的计算方法不同于schedule，而是scheduledExecutionTime(n)=firstExecuteTime +n*periodTime，

  该计算方法永远保持不变。所以scheduleAtFixedRate更加侧重于保持执行频率的稳定。

如何终止Timer线程

　　默认情况下，创建的timer线程会一直执行，主要有下面四种方式来终止timer线程：

• 调用timer的cancle方法
• 把timer线程设置成daemon线程，（new Timer(true)创建daemon线程），在jvm里，如果所有用户线程结束，那么守护线程也会被终止，不过这种方法一般不用。
• 当所有任务执行结束后，删除对应timer对象的引用，线程也会被终止。
• 调用System.exit方法终止程序

注意：

• 每一个Timer仅对应唯一一个线程。
• Timer不保证任务执行的十分精确。
• Timer类的线程安全的。

 // Timer和TimerTask可以做为实现线程的第三种方式，前两中方式分别是继承自Thread类和实现Runnable接口。

比如设计一个连环地雷阵，2秒后爆炸一次，3秒后爆炸一次，依次循环下去

package run;

import java.util.Timer;
import java.util.TimerTask;

public class TimerTaskRun1 extends TimerTask{

	@Override
	public void run() {
			System.out.println("爆炸");
			new Timer().schedule(new TimerTaskRun2(), 2000);
	}
	
}

package run;

import java.util.Timer;
import java.util.TimerTask;

public class TimerTaskRun2 extends TimerTask{

	@Override
	public void run() {
		System.out.println("爆炸!!!!!!!!");
		new Timer().schedule(new TimerTaskRun1(), 3000);
	}

}

package run;

import java.util.Date;
import java.util.Timer;

public class testRun {
	public static void main(String[] args) {
		Timer timer = new Timer();
		timer.schedule(new TimerTaskRun1(), 2000);
		while (true) {
			System.out.println(new Date().getSeconds());
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
}

运行结果：

 

缺点

用Timer调度任务时，必须确保时间间隔超过正常程序运行时间，否则任务队列的大小将持续增长，最终程序将无法停止。

java.util.Timer计时器有管理任务延迟执行，,Timer对调度的支持是基于绝对时间,而不是相对时间的，比如schedule(TimerTask task, 2000, 1000) ：
如果TimerTask抛出未检查的异常，Timer将会产生无法预料的行为。Timer线程并不捕获异常，所以TimerTask抛出的未检查的异常会终止
timer线程。这种情况下，Timer也不会再重新恢复线程的执行了;它错误的认为整个Timer都被取消了。此时，已经被安排但尚未执行的
TimerTask永远不会再执行了，新的任务也不能被调度了。
Timer单线程执行任务，任务有可能丢失或执行时间不准确。