【并发技术02】传统线程技术中的定时器技术

传统线程技术中有个定时器，定时器的类是 Timer，我们使用定时器的目的就是给它安排任务，让它在指定的时间完成任务。所以先来看一下 Timer 类中的方法（主要看常用的 TimerTask() 方法）：

返回值	方法名	方法描述
void	schedule(TimerTasktask,longdelay)	安排在指定延迟后执行指定的任务。
void	schedule(TimerTasktask,longdelay,longperiod)	安排指定的任务从指定的延迟后开始进行重复的固定延迟执行。
void	schedule(TimerTasktask,Datetime)	安排在指定的时间执行指定的任务
void	schedule(TimerTasktask,DatefirstTime,longperiod)	安排指定的任务在指定的时间开始进行重复的固定延迟执行。

前面两个是在指定延迟后执行或者重复执行，后面两个是在指定时间执行或者重复执行。我们以前两个为例来研究一下定时器的使用。先写一个简单的使用定时器的 demo，然后慢慢引申。

1. public class TraditionalTimer {

2.    public static void main(String[] args) {

3.        //简单定时器的demo

4.        new Timer().schedule(new TimerTask() {          

5.            @Override

6.            public void run() {

7.                //实际中会扔一个对象进来，我们就可以在这里操作这个对象的所有方法了

8.                System.out.println("--boom--");//爆炸

9.            }

10.        }, 2000,3000);

11.        //打印秒钟，一秒输出一次,用来方便观察的

12.        while(true) {

13.            System.out.println(new Date().getSeconds());

14.            try {

15.                Thread.sleep(1000);

16.            } catch(Exception e) {

17.                e.printStackTrace();

18.            }

19.        }

20.    }

21. }

我们用匿名内部类来定义了一个 TimerTask 对象，需要重写 run() 方法，然后运行这个程序，可以看出来第一次2秒钟后打印 “--boom--，后面每隔3秒打印一次。
我们也可以自己来实现上面这个重复执行，我们用定时器的 “连环套”！也就是定时器中再套定时器，一个定时器任务执行完了，在任务的最后再装一个定时器。那么我们需要先定义一个自己的定时器任务，在自己的定时器任务中再装一个定时器，把自定义的定时器任务扔进去。然后我们开启定时器的时候把自己定义的定时器任务扔进去即可。如下：

1. public class TraditionalTimer {

2.    public static void main(String[] args) {

3.        //自定义一个定时器任务

4.        class MyTimerTask extends TimerTask {          

5.            @Override

6.            public void run() {

7.                System.out.println("--boom--");

8.                //任务执行完再装一个定时器，扔进自定义的定时器任务

9.                new Timer().schedule(new MyTimerTask(), 3000);

10.            }

11.        }

12.        new Timer().schedule(new MyTimerTask(), 2000);//外面开启定时器

13.        while(true) {//打印秒钟，一秒输出一次

14.            System.out.println(new Date().getSeconds());

15.            try {

16.                Thread.sleep(1000);

17.            } catch(Exception e) {

18.                e.printStackTrace();

19.            }

20.        }

21.    }

22. }

这样的话，我们通过定时器的 “连环套” 很轻松的实现了连环爆炸。但是现在问题来了，上面提供的方法中重复执行都是每隔固定的时间，如果我想要隔2秒执行一次，再隔4秒执行一次，再隔2秒执行一次，再隔4秒执行一次……这该如何实现呢？
可以这样，我们定义一个全局的私有成员变量来记录爆炸次数，奇数的时候隔2秒炸，偶数的次数的话隔4秒炸，或者反过来也行，修改如下：

1. public class TraditionalTimer {

2.    private static int count = 0; //记录爆炸的次数

3.    public static void main(String[] args) {    

4.        class MyTimerTask extends TimerTask {          

5.            @Override

6.            public void run() {

7.                count = (count + 1) % 2; //结果只有0和1

8.                System.out.println("--boom--");

9.                                //根据count结果设定新的定时时间

10.                new Timer().schedule(new MyTimerTask(), 2000+2000*count);

11.            }

12.        }

13.        new Timer().schedule(new MyTimerTask(), 2000);

14.        while(true) {//打印秒钟，一秒输出一次

15.            System.out.println(new Date().getSeconds());

16.            try {

17.                Thread.sleep(1000);

18.            } catch(Exception e) {

19.                e.printStackTrace();

20.            }

21.        }

22.    }

23. }

这样的话，我们就实现了自定义爆炸间隔了。上面这个是通过定义一个全局私有变量来实现，其实我们也可以这么干：不是要实现两个不同时间间隔的连环炸么？我可以定义两个定时器任务A和B，在A执行完开启定时器，把B任务装进去，B执行完开启定时器把A装进去，这样也可以。如下：

1. public class TraditionalTimer {

2.    public static void main(String[] args) {

3.        new Timer().schedule(new MyTimerTaskA(), 2000);//A和B随便开一个

4.        while(true) {//打印秒钟，一秒输出一次

5.            System.out.println(new Date().getSeconds());

6.            try {

7.                Thread.sleep(1000);

8.            } catch(Exception e) {

9.                e.printStackTrace();

10.            }

11.        }

12.    }

13. }

14. //自定义两个定时器任务类，继承TimerTask即可

15. class MyTimerTaskA extends TimerTask {

16.    @Override

17.    public void run() {

18.        System.out.println("--boomA--");

19.        new Timer().schedule(new MyTimerTaskB(), 4000);

20.    }          

21. }

22. class MyTimerTaskB extends TimerTask {

23.    @Override

24.    public void run() {

25.        System.out.println("--boomB--");

26.        new Timer().schedule(new MyTimerTaskA(), 2000);

27.    }  

28. }

这样就可以实现自定义时间间隔的连环炸了。传统的定时器技术就总结这么多吧。

如果觉得对您有帮助，转发给更多人吧~