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

原文地址

运行时修改TimerTask的执行周期 

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

Java代码  

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

    

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

Java代码  

1. public abstract class ReschedulableTimerTask extends TimerTask {  
2.     public void setPeriod(long period) {  
3.         //缩短周期，执行频率就提高  
4.         setDeclaredField(TimerTask.class, this, "period", period);  
5.     }  
6.       
7.     //通过反射修改字段的值  
8.     static boolean setDeclaredField(Class<?> clazz, Object obj,  
9.             String name, Object value) {  
10.         try {  
11.             Field field = clazz.getDeclaredField(name);  
12.             field.setAccessible(true);  
13.             field.set(obj, value);  
14.             return true;  
15.         } catch (Exception ex) {  
16.             ex.printStackTrace();  
17.             return false;  
18.         }  
19.     }  
20. }  

测试类 

Java代码  

1. import java.text.SimpleDateFormat;  
2. import java.util.Date;  
3. import java.util.Timer;  
4. import java.util.TimerTask;  
5. public class Tester {  
6.     public static void main(String[] args){  
7.         ReschedulableTimerTask task=new ReschedulableTimerTask() {  
8.               
9.             @Override  
10.             public void run() {  
11.                 System.out.println("RunTime:"+new SimpleDateFormat("HH:mm:ss").format(new Date()));               
12.             }  
13.         };  
14.         Timer timer=new Timer();  
15.         timer.schedule(task, 2000, 2000);//每两秒执行一次  
16.         try {  
17.             Thread.sleep(6000);  
18.         } catch (InterruptedException e) {  
19.         }  
20.         //主线程6秒后，更改任务周期  
21.         task.setPeriod(1000);//改为每秒执行一次  
22.     }  
23. }  

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

引用

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

注意：

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

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

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

[java]  view plain copy

1. package com.yasi;  
2.   
3. import java.lang.reflect.Field;  
4. import java.text.SimpleDateFormat;  
5. import java.util.Date;  
6. import java.util.Timer;  
7. import java.util.TimerTask;  
8.   
9. public class Test extends TimerTask {  
10.     public int CHECK_INTERVAL = 4 * 1000;  
11.     public int NEW_CHECK_INTERVAL = 1 * 1000;  
12.       
13.     public void schedule() {  
14.         Timer timer = new Timer();  
15.         timer.scheduleAtFixedRate(this, 0, CHECK_INTERVAL);  
16.     }  
17.       
18.     public void re_schedule() {  
19.         setDeclaredField(TimerTask.class, this, "period", NEW_CHECK_INTERVAL);  
20.     }  
21.       
22.     static boolean setDeclaredField(Class<?> clazz, Object obj,  
23.             String name, Object value) {  
24.         try {  
25.             Field field = clazz.getDeclaredField(name);  
26.             field.setAccessible(true);  
27.             field.set(obj, value);  
28.             return true;  
29.         } catch (Exception ex) {  
30.             ex.printStackTrace();  
31.             return false;  
32.         }  
33.     }  
34.       
35.     @Override  
36.     public void run() {  
37.         Date now = new Date();  
38.         SimpleDateFormat dateFormat = new SimpleDateFormat(  
39.                 "E MMMMM dd HH:mm:ss zzz yyyy");  
40.         System.out.println(dateFormat.format(now).toString());  
41.     }  
42.       
43.     public static void main(String[] args) {  
44.         Test t = new Test();  
45.         t.schedule();  
46.           
47.         try {  
48.             Thread.sleep(5 * 1000);  
49.         } catch (Exception e) {  
50.             System.out.println(e);  
51.         }  
52.           
53.         t.re_schedule();  
54.     }  
55. }  

输出如下：

[plain]  view plain copy

1. Mon May 12 15:36:27 CST 2014  
2. Mon May 12 15:36:31 CST 2014  
3. Mon May 12 15:36:35 CST 2014  
4. Mon May 12 15:36:36 CST 2014  
5. Mon May 12 15:36:37 CST 2014  
6. Mon May 12 15:36:38 CST 2014  

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

[plain]  view plain copy

1. Mon May 12 15:36:27 CST 2014  
2. Mon May 12 15:36:31 CST 2014  
3. Mon May 12 15:36:32 CST 2014  
4. Mon May 12 15:36:33 CST 2014  
5. Mon May 12 15:36:34 CST 2014  
6. Mon May 12 15:36:35 CST 2014  

然而，事实情况是：

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

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

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

下面给出正确的做法：

[java]  view plain copy

1. package com.yasi;  
2.   
3. import java.lang.reflect.Field;  
4. import java.text.SimpleDateFormat;  
5. import java.util.Date;  
6. import java.util.Timer;  
7. import java.util.TimerTask;  
8.   
9. public class Test extends TimerTask {  
10.     public int CHECK_INTERVAL = 4 * 1000;  
11.     public int NEW_CHECK_INTERVAL = 1 * 1000;  
12.     public int i = 0;  
13.       
14.     public void schedule() {  
15.         Timer timer = new Timer();  
16.         timer.scheduleAtFixedRate(this, 0, CHECK_INTERVAL);  
17.     }  
18.       
19.     public void re_schedule1() {  
20.         Date now = new Date();  
21.         SimpleDateFormat dateFormat = new SimpleDateFormat(  
22.                 "E MMMMM dd HH:mm:ss zzz yyyy");  
23.         System.out.println("re_schedule1:" + dateFormat.format(now).toString());  
24.           
25.         setDeclaredField(TimerTask.class, this, "period", NEW_CHECK_INTERVAL);  
26.     }  
27.       
28.     public void re_schedule2() {  
29.         Date now = new Date();  
30.         SimpleDateFormat dateFormat = new SimpleDateFormat(  
31.                 "E MMMMM dd HH:mm:ss zzz yyyy");  
32.         System.out.println("re_schedule2:" + dateFormat.format(now).toString());  
33.           
34.         long nextExecutionTime = now.getTime() + NEW_CHECK_INTERVAL;  
35.           
36.         setDeclaredField(TimerTask.class, this, "nextExecutionTime", nextExecutionTime);  
37.         setDeclaredField(TimerTask.class, this, "period", NEW_CHECK_INTERVAL);  
38.     }  
39.       
40.     static boolean setDeclaredField(Class<?> clazz, Object obj,  
41.             String name, Object value) {  
42.         try {  
43.             Field field = clazz.getDeclaredField(name);  
44.             field.setAccessible(true);  
45.             field.set(obj, value);  
46.             return true;  
47.         } catch (Exception ex) {  
48.             ex.printStackTrace();  
49.             return false;  
50.         }  
51.     }  
52.       
53.     @Override  
54.     public void run() {  
55.   
56.         Date now = new Date();  
57.         SimpleDateFormat dateFormat = new SimpleDateFormat(  
58.                 "E MMMMM dd HH:mm:ss zzz yyyy");  
59.         System.out.println(dateFormat.format(now).toString());  
60.           
61.         i++;  
62.         if(i == 3) {  
63.             //re_schedule1();  
64.             re_schedule2();  
65.         }  
66.     }  
67.       
68.     public static void main(String[] args) {  
69.         Test t = new Test();  
70.         t.schedule();  
71.     }  
72. }  

注意：

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

[java]  view plain copy

1. package com.yasi;  
2.   
3. public interface ITask {  
4.     public void run();  
5.     public long getPeriod();  
6. }  

ReschedulableTimerTask.java

[java]  view plain copy

1. package com.yasi;  
2.   
3. import java.util.Timer;  
4. import java.util.TimerTask;  
5.   
6. public class ReschedulableTimerTask extends TimerTask {  
7.     Timer master;  
8.     ITask task;  
9.       
10.     public ReschedulableTimerTask(Timer master, ITask task)  {  
11.         this.master = master;  
12.         this.task = task;  
13.     }  
14.       
15.     @Override  
16.     public void run() {  
17.         task.run();  
18.         master.schedule(new ReschedulableTimerTask(master,task), task.getPeriod());  
19.     }  
20. }  

ConcreteTask.java

[java]  view plain copy

1. package com.yasi;  
2.   
3. public class ConcreteTask implements ITask {  
4.     private long period = 4000;  
5.     private int i = 0;  
6.       
7.     @Override  
8.     public void run() {  
9.         i++;  
10.         if (2 != i) {  
11.             System.out.println("ConcreteTask: " + System.currentTimeMillis());  
12.         } else {  
13.             period = 1000;  
14.             System.out.println("ConcreteTask: " + System.currentTimeMillis() + " reset period to 1000 ms");  
15.         }  
16.     }  
17.       
18.     @Override  
19.     public long getPeriod() {  
20.         return period;  
21.     }  
22. }  

Test.java

[java]  view plain copy

1. package com.yasi;  
2.   
3. import java.util.Timer;  
4.   
5. public class Test {  
6.   
7.     public static void main(String[] args) {  
8.         ConcreteTask task = new ConcreteTask();  
9.           
10.         System.out.println("Start timer:  " + System.currentTimeMillis());  
11.           
12.         Timer timer = new Timer();  
13.         timer.schedule(new ReschedulableTimerTask(timer, task) , 4000);  
14.     }  
15. }  

输出如下：

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