通过Java反射在运行时修改TimerTask的执行周期并且立即生效

参考：http://chen-yongkai.iteye.com/blog/1673241

原文摘抄如下：

运行时修改TimerTask的执行周期 

java.util.TimerTask类的执行周期period变量的声明如下： 

 /**
  * Period in milliseconds for repeating tasks.  A positive value indicates
  * fixed-rate execution.  A negative value indicates fixed-delay execution.
  * A value of 0 indicates a non-repeating task.
  */
 long period = 0;

    

TimerTask并未提供修改period的公共方法，但我们可以借助java反射修改其值。 
    

 public abstract class ReschedulableTimerTask extends TimerTask {
     public void setPeriod(long period) {
         //缩短周期，执行频率就提高
         setDeclaredField(TimerTask.class, this, "period", period);
     }

     //通过反射修改字段的值
     static boolean setDeclaredField(Class<?> clazz, Object obj,
             String name, Object value) {
         try {
             Field field = clazz.getDeclaredField(name);
             field.setAccessible(true);
             field.set(obj, value);
             return true;
         } catch (Exception ex) {
             ex.printStackTrace();
             return false;
         }
     }
 }

测试类 

 import java.text.SimpleDateFormat;
 import java.util.Date;
 import java.util.Timer;
 import java.util.TimerTask;
 public class Tester {
     public static void main(String[] args){
         ReschedulableTimerTask task=new ReschedulableTimerTask() {

             @Override
             public void run() {
                 System.out.println("RunTime:"+new SimpleDateFormat("HH:mm:ss").format(new Date()));
             }
         };
         Timer timer=new Timer();
         timer.schedule(task, 2000, 2000);//每两秒执行一次
         try {
             Thread.sleep(6000);
         } catch (InterruptedException e) {
         }
         //主线程6秒后，更改任务周期
         task.setPeriod(1000);//改为每秒执行一次
     }
 }

如果想通过停止任务再重新调用schedule来安排一个新的执行周期，也是可行的，但是要重新创建TimerTask对象； 
因为TimerTask对象在安排执行或者取消执行后，其内部状态（由state指定）已经发生变化，是不可以重新安排执行， 
否则会抛出IllegalStateException异常。 

引用

public void scheduleAtFixedRate(TimerTask task, 
                                long delay, 
                                long period) 
抛出： 
IllegalArgumentException - 如果 delay 是负数，或者 delay + System.currentTimeMillis() 是负数。 
IllegalStateException - 如果已经安排或取消了任务，已经取消了计时器，或者计时器线程已终止。                                

注意：

jdk没有提供setPeriod方法可能是出于线程安全的考虑， 
如果你要使用以上的方法在运行时动态修改任务的执行频率， 
你要自己保证代码的线程安全。 
建议在简单的并且运行时间较短的任务中使用。

==========【yasi】==========

自己实践了一下，代码如下：

package com.yasi;

import java.lang.reflect.Field;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

public class Test extends TimerTask {
	public int CHECK_INTERVAL = 4 * 1000;
	public int NEW_CHECK_INTERVAL = 1 * 1000;
	
	public void schedule() {
		Timer timer = new Timer();
		timer.scheduleAtFixedRate(this, 0, CHECK_INTERVAL);
	}
	
	public void re_schedule() {
		setDeclaredField(TimerTask.class, this, "period", NEW_CHECK_INTERVAL);
	}
	
	static boolean setDeclaredField(Class<?> clazz, Object obj,
			String name, Object value) {
		try {
			Field field = clazz.getDeclaredField(name);
			field.setAccessible(true);
			field.set(obj, value);
			return true;
		} catch (Exception ex) {
			ex.printStackTrace();
			return false;
		}
	}
	
	@Override
	public void run() {
		Date now = new Date();
		SimpleDateFormat dateFormat = new SimpleDateFormat(
				"E MMMMM dd HH:mm:ss zzz yyyy");
		System.out.println(dateFormat.format(now).toString());
	}
	
	public static void main(String[] args) {
		Test t = new Test();
		t.schedule();
		
		try {
			Thread.sleep(5 * 1000);
		} catch (Exception e) {
			System.out.println(e);
		}
		
		t.re_schedule();
	}
}

输出如下：

Mon May 12 15:36:27 CST 2014
Mon May 12 15:36:31 CST 2014
Mon May 12 15:36:35 CST 2014
Mon May 12 15:36:36 CST 2014
Mon May 12 15:36:37 CST 2014
Mon May 12 15:36:38 CST 2014

初始时的timer的周期为4秒，主线程在第5秒的时候，重置了timer的周期为1秒。 自己本来期望的输出是下面这样的，即在第5秒的时刻，立即重启timer并执行一次timer，然后就按照新的周期执行timer。

Mon May 12 15:36:27 CST 2014
Mon May 12 15:36:31 CST 2014
Mon May 12 15:36:32 CST 2014
Mon May 12 15:36:33 CST 2014
Mon May 12 15:36:34 CST 2014
Mon May 12 15:36:35 CST 2014

然而，事实情况是：

假设在第N个周期中重置了timer的周期，那么必须等第N个周期（按照先前的周期）执行完了以后，新的周期才会生效。

也许，这不是很多人期望的结果。

反编译 rt.jar 中的TimerTask.class 后，看到该类中，除了 long period 属性外，还有一个 long nextExecutionTime 属性。猜想这个值在执行到当前的 run() 函数之前，就已经计算好了，于是，在run() 中除了要修改 peirod 属性外，还要修改 nextExecutionTime 属性。实践了一下，结果确实是那样的。

下面给出正确的做法：

package com.yasi;

import java.lang.reflect.Field;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

public class Test extends TimerTask {
	public int CHECK_INTERVAL = 4 * 1000;
	public int NEW_CHECK_INTERVAL = 1 * 1000;
	public int i = 0;
	
	public void schedule() {
		Timer timer = new Timer();
		timer.scheduleAtFixedRate(this, 0, CHECK_INTERVAL);
	}
	
	public void re_schedule1() {
		Date now = new Date();
		SimpleDateFormat dateFormat = new SimpleDateFormat(
				"E MMMMM dd HH:mm:ss zzz yyyy");
		System.out.println("re_schedule1:" + dateFormat.format(now).toString());
		
		setDeclaredField(TimerTask.class, this, "period", NEW_CHECK_INTERVAL);
	}
	
	public void re_schedule2() {
		Date now = new Date();
		SimpleDateFormat dateFormat = new SimpleDateFormat(
				"E MMMMM dd HH:mm:ss zzz yyyy");
		System.out.println("re_schedule2:" + dateFormat.format(now).toString());
		
		long nextExecutionTime = now.getTime() + NEW_CHECK_INTERVAL;
		
		setDeclaredField(TimerTask.class, this, "nextExecutionTime", nextExecutionTime);
		setDeclaredField(TimerTask.class, this, "period", NEW_CHECK_INTERVAL);
	}
	
	static boolean setDeclaredField(Class<?> clazz, Object obj,
			String name, Object value) {
		try {
			Field field = clazz.getDeclaredField(name);
			field.setAccessible(true);
			field.set(obj, value);
			return true;
		} catch (Exception ex) {
			ex.printStackTrace();
			return false;
		}
	}
	
	@Override
	public void run() {

		Date now = new Date();
		SimpleDateFormat dateFormat = new SimpleDateFormat(
				"E MMMMM dd HH:mm:ss zzz yyyy");
		System.out.println(dateFormat.format(now).toString());
		
		i++;
		if(i == 3) {
			//re_schedule1();
			re_schedule2();
		}
	}
	
	public static void main(String[] args) {
		Test t = new Test();
		t.schedule();
	}
}

注意：

re_schedule2() 方法中，除了在第37行重置了TimerTask的"period"属性，同时在第36行重置了"nextExecutionTime"属性，从而直接修改了下一次执行的时刻，避免了一次多余的“旧的period”的执行。

上面的代码用re_schedule2()执行的结果如下。可见，执行了re_schedule2()之后，新的period 是 “即刻生效” 的。

Wed May 14 08:22:53 CST 2014
Wed May 14 08:22:57 CST 2014
Wed May 14 08:23:01 CST 2014
re_schedule2:Wed May 14 08:23:01 CST 2014
Wed May 14 08:23:02 CST 2014
Wed May 14 08:23:03 CST 2014
Wed May 14 08:23:04 CST 2014
Wed May 14 08:23:05 CST 2014

=====【另外一种方法】=======

上面的方法是通过反射来做的，下面的方法不用反射，也能达到同样的目的。

ITask.java

package com.yasi;

public interface ITask {
	public void run();
	public long getPeriod();
}

ReschedulableTimerTask.java

package com.yasi;

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

public class ReschedulableTimerTask extends TimerTask {
	Timer master;
	ITask task;
	
	public ReschedulableTimerTask(Timer master, ITask task)  {
		this.master = master;
		this.task = task;
	}
	
	@Override
	public void run() {
		task.run();
		master.schedule(new ReschedulableTimerTask(master,task), task.getPeriod());
	}
}

ConcreteTask.java

package com.yasi;

public class ConcreteTask implements ITask {
	private long period = 4000;
	private int i = 0;
	
	@Override
	public void run() {
		i++;
		if (2 != i) {
			System.out.println("ConcreteTask: " + System.currentTimeMillis());
		} else {
			period = 1000;
			System.out.println("ConcreteTask: " + System.currentTimeMillis() + " reset period to 1000 ms");
		}
	}
	
	@Override
	public long getPeriod() {
		return period;
	}
}

Test.java

package com.yasi;

import java.util.Timer;

public class Test {

	public static void main(String[] args) {
		ConcreteTask task = new ConcreteTask();
		
		System.out.println("Start timer:  " + System.currentTimeMillis());
		
		Timer timer = new Timer();
		timer.schedule(new ReschedulableTimerTask(timer, task) , 4000);
	}
}

输出如下：

      Start timer:  1400218487767
ConcreteTask: 1400218491767
ConcreteTask: 1400218495767 reset period to 1000 ms
ConcreteTask: 1400218496767
ConcreteTask: 1400218497767
ConcreteTask: 1400218498767