dtimer.java

DTimer.java封装的定时器类,适用于后台定时器



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

/**
 * 封装的定时器类
 *文件名：DTimer.java<br>
 *@author 董利伟<br>
 *版本:<br>
 *描述：<br>
 *创建时间:2007-11-2 上午11:18:10<br>
 *文件描述：<br>
 *修改者：<br>
 *修改日期：<br>
 *修改描述：<br>
 */
public abstract class DTimer {

	private TimerTask timertask;
	private Timer timer = new Timer();
	/**
	 * 创建一个新计时器。相关的线程不 作为守护程序运行。
	 */
	public void setTimer(){
		this.timer = new Timer();
	}
	/**
	 * 创建一个新计时器，可以指定其相关的线程作为守护程序运行。
	 * 如果计时器将用于安排重复的“维护活动”，则调用守护线程，
	 * 在应用程序运行期间必须调用守护线程，但是该操作不应延长
	 * 程序的生命周期。 
	 * @param isDaemon 如果应该将相关的线程作为守护程序运行，则为 true。
	 */
	public void setTimer(boolean isDaemon){
		this.timer = new Timer(isDaemon);
	}
	/**
	 * 创建一个新计时器，其相关的线程具有指定的名称。
	 * 相关的线程不 作为守护程序运行。
	 * @param name 相关线程的名称
	 * @throws NullPointerException
	 */
	public void setTimer(String name)throws NullPointerException{
		this.timer = new Timer(name);
	}
	/**
	 * 创建一个新计时器，其相关的线程具有指定的名称，并且可以指定作为守护程序运行。
	 * @param name 相关线程的名称
	 * @param isDaemon 如果应该将相关的线程作为守护程序运行，则为 true
	 * @throws NullPointerException
	 */
	public void setTimer(String name,boolean isDaemon)throws NullPointerException{
		this.timer = new Timer(name,isDaemon);
	}
	/**
	 * 安排在指定延迟后执行指定的任务。
	 * @param delay 执行任务前的延迟时间，单位是毫秒。
	 */
	public void schedule(long delay)throws IllegalArgumentException,IllegalStateException{
		if(this.timer == null){
			this.timer = new Timer();
		}
		this.timertask = new DTask();
		this.timer.schedule(this.timertask,delay);
	}
	/**
	 * 安排在指定的时间执行指定的任务。如果此时间已过去，则安排立即执行该任务。
	 * @param date 执行任务的时间
	 */
	public void schedule(Date date)throws IllegalArgumentException,IllegalStateException{
		if(this.timer == null){
			this.timer = new Timer();
		}
		this.timertask = new DTask();
		this.timer.schedule(this.timertask,date);
	}
	/**
	 * 安排指定的任务从指定的延迟后开始进行重复的固定延迟执行。以近似固定的时间间隔（由指定的周期分隔）进行后续执行。
	 * 在固定延迟执行中，根据前一次执行的实际执行时间来安排每次执行。如果由于任何原因（如垃圾回收或其他后台活动）而
	 * 延迟了某次执行，则后续执行也将被延迟。从长期来看，执行的频率一般要稍慢于指定周期的倒数（假定 Object.wait(long)
	 * 所依靠的系统时钟是准确的）。 固定延迟执行适用于那些需要“平稳”运行的重复活动。换句话说，它适用于在短期运行
	 * 中保持频率准确要比在长期运行中更为重要的活动。这包括大多数动画任务，如以固定时间间隔闪烁的光标。这还包括为响
	 * 应人类活动所执行的固定活动，如在按住键时自动重复输入字符。 
	 * @param delay 执行任务前的延迟时间，单位是毫秒
	 * @param period 执行各后续任务之间的时间间隔，单位是毫秒
	 * @throws IllegalArgumentException
	 * @throws IllegalStateException
	 */
	public void schedule(long delay,long period)throws IllegalArgumentException,IllegalStateException{
		if(this.timer == null){
			this.timer = new Timer();
		}
		this.timertask = new DTask();
		this.timer.schedule(this.timertask,delay,period);
	}
	/**
	 * 安排指定的任务在指定的时间开始进行重复的固定延迟执行。以近似固定的时间间隔（由指定的周期分隔）进行后续执行。 
	 * 在固定延迟执行中，根据前一次执行的实际执行时间来安排每次执行。如果由于任何原因（如垃圾回收或其他后台活动）
	 * 而延迟了某次执行，则后续执行也将被延迟。在长期运行中，执行的频率一般要稍慢于指定周期的倒数（假定 Object.wait(long) 
	 * 所依靠的系统时钟是准确的）。 固定延迟执行适用于那些需要“平稳”运行的重复执行活动。换句话说，它适用于在短期
	 * 运行中保持频率准确要比在长期运行中更为重要的活动。这包括大多数动画任务，如以固定时间间隔闪烁的光标。这还包
	 * 括为响应人类活动所执行的固定活动，如在按住键时自动重复输入字符。 
	 * @param firstTime 首次执行任务的时间
	 * @param period 执行各后续任务之间的时间间隔，单位是毫秒
	 * @throws IllegalArgumentException
	 * @throws IllegalStateException
	 */
	public void schedule(Date firstTime,long period)throws IllegalArgumentException,IllegalStateException{
		if(this.timer == null){
			this.timer = new Timer();
		}
		this.timertask = new DTask();
		this.timer.schedule(this.timertask,firstTime,period);
	}
	/**
	 * 安排指定的任务在指定的延迟后开始进行重复的固定速率执行。以近似固定的时间间隔（由指定的周期分隔）进行后续执行。 
	 * 在固定速率执行中，根据已安排的初始执行时间来安排每次执行。如果由于任何原因（如垃圾回收或其他背景活动）而延迟
	 * 了某次执行，则将快速连续地出现两次或更多的执行，从而使后续执行能够“追赶上来”。从长远来看，执行的频率将正好是
	 * 指定周期的倒数（假定 Object.wait(long) 所依靠的系统时钟是准确的）。 固定速率执行适用于那些对绝对 时间敏
	 * 感的重复执行活动，如每小时准点打钟报时，或者在每天的特定时间运行已安排的维护活动。它还适用于那些完成固定次数
	 * 执行的总计时间很重要的重复活动，如倒计时的计时器，每秒钟滴答一次，共 10 秒钟。最后，固定速率执行适用于安排多
	 * 个重复执行的计时器任务，这些任务相互之间必须保持同步。
	 * @param delay 执行任务前的延迟时间，单位是毫秒。
	 * @param period 执行各后续任务之间的时间间隔，单位是毫秒。
	 * @throws IllegalArgumentException
	 * @throws IllegalStateException
	 */
	public void scheduleAtFixedRate(long delay,long period)throws IllegalArgumentException,IllegalStateException{
		if(this.timer == null){
			this.timer = new Timer();
		}
		this.timertask = new DTask();
		this.timer.scheduleAtFixedRate(this.timertask,delay,period);
	}
	/**
	 * 安排指定的任务在指定的时间开始进行重复的固定速率执行。以近似固定的时间间隔（由指定的周期分隔）进行后续执行。 
	 * 在固定速率执行中，相对于已安排的初始执行时间来安排每次执行。如果由于任何原因（如垃圾回收或其他背景活动）而
	 * 延迟了某次执行，则将快速连续地出现两次或更多次执行，从而使后续执行能够赶上来。从长远来看，执行的频率将正好
	 * 是指定周期的倒数（假定 Object.wait(long) 所依靠的系统时钟是准确的）。 固定速率执行适用于那些对绝对时
	 * 间敏感的重复执行活动，如每小时准点打钟报时，或者在每天的特定时间运行已安排的维护活动。它还适用于那些完成固
	 * 定次数执行的总计时间很重要的重复活动，如倒计时的计时器，每秒钟滴答一次，共 10 秒钟。最后，固定速率执行适用
	 * 于安排多次重复执行的计时器任务，这些任务相互之间必须保持同步。
	 * @param firstTime 首次执行任务的时间
	 * @param period 执行各后续任务之间的时间间隔，单位是毫秒
	 * @throws IllegalArgumentException
	 * @throws IllegalStateException
	 */
	public void scheduleAtFixedRate(Date firstTime,long period)throws IllegalArgumentException,IllegalStateException{
		if(this.timer == null){
			this.timer = new Timer();
		}
		this.timertask = new DTask();
		this.timer.scheduleAtFixedRate(this.timertask,firstTime,period);
	}
	
	private class DTask extends TimerTask{
		public void run() {
			work();
		}
	}
	/**
	 * 取消此计时器任务。如果任务安排为一次执行且还未运行，或者尚未安排，则永远不会运行。如果任务安排为重复执行，
	 * 则永远不会再运行。（如果发生此调用时任务正在运行，则任务将运行完，但永远不会再运行。） 注意，从重复的计时
	 * 器任务的 run 方法中调用此方法绝对保证计时器任务永远不会再运行。 此方法可以反复调用；第二次和以后的调用无效。
	 * @return 如果此任务安排为一次执行且尚未运行，或者此任务安排为重复执行，则返回 true。
	 *         如果此任务安排为一次执行且已经运行，或者此任务尚未安排，或者此任务已经取消，
	 *         则返回 false。（一般来说，如果此方法阻止发生一个或多个安排执行，则返回 true。）
	 */
	public boolean cancel(){
		if(this.timertask == null){
			return true;
		}
		if(this.timer == null){
			return true;
		}
		boolean bn = this.timertask.cancel();
		this.timer.cancel();
		return bn;
	}
	/**
	 * 返回此任务最近实际 执行的安排 执行时间。（如果在任务执行过程中调用此方法，则返回值为此任务执行的安排执行时间。）
	 * 通常从一个任务的 run 方法中调用此方法，以确定当前任务执行是否能充分及时地保证完成安排活动： 
	 * public void run() {
	 * 		if (System.currentTimeMillis() - scheduledExecutionTime() >=MAX_TARDINESS){
	 * 			return;  // Too late; skip this execution.
	 * 			// Perform the task
	 * 		} 
	 * }
	 * 通常，此方法不 与固定延迟执行 的重复任务一起使用，因为其安排执行时间允许随时间浮动，所以毫无意义。
	 * @return 最近发生此任务执行安排的时间，采用 Date.getTime() 返回的格式。如果任务已开始其首次执行，则返回值不确定。
	 */
	public long scheduledExecutionTime(){
		if(this.timertask == null){
			return 0;
		}
		return this.timertask.scheduledExecutionTime();
	}
	/**
	 * 将要执行的任务，用于让其子类进行覆盖
	 */
	public abstract void work();
}