多线程并发编程（二）：定时器的应用

迈不过友情╰ 2022-07-30 14:57 164阅读 0赞

# 定时器的应用 #

# **Timer** #

> 主要是几种应用场景的使用

## **示例应用场景1：设定一个定时器，10秒之后爆炸** ##

package test01;
    
    import java.util.Date;
    import java.util.Timer;
    import java.util.TimerTask;
    
    public class TraditionalTimerTest { 
    
        public static void main(String[] args) {
    
            new Timer().schedule(new TimerTask() {
    
                @Override
                public void run() {
                    System.out.println("boom!");
                }
    
            }, 10000);
    
            while(true){
                System.out.println(new Date().getSeconds());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
    
        }
    }

输出结果：  
![这里写图片描述][20160419121622838]

## **示例应用场景2：设定一个定时器，10秒之后爆炸，之后每隔3秒炸一次** ##

其实就是一个API的问题

package test01;
    
    import java.util.Timer;
    import java.util.TimerTask;
    
    public class TraditionalTimerTest { 
    
        public static void main(String[] args) {
            new Timer().schedule(new TimerTask() {
    
                @Override
                public void run() {
                    System.out.println("boom!");
                }
            }, 10000,3000);
        }
    }

## **示例应用场景3：设定一个定时器，2秒之后爆炸，之后4秒炸一次，然后2秒后再炸一次，4秒炸一次，依次循环** ##

### **实现方式一：一个定时任务，使用静态变量的值来控制时间** ###

package test01;
    
    import java.util.Date;
    import java.util.Timer;
    import java.util.TimerTask;
    
    public class TraditionalTimerTest { 
        // 设定一个静态变量用来区分是哪个定时器
        static int count = 0;
    
        public static void main(String[] args) {
            class MyTimerTask extends TimerTask{
    
                @Override
                public void run() {
                    count = (count + 1) % 2;
                    System.out.println("boom!");
                    new Timer().schedule(new MyTimerTask(), 2000+2000*count);
                }
    
            }
            new Timer().schedule(new MyTimerTask(), 2000);
    
            // 每隔一秒打印时间，方便观察作用，可以去掉
            while(true){
                System.out.println(new Date().getSeconds());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
    
        }
    }

打印结果：  
![这里写图片描述][20160419131941832]  
通过上面的打印结果可以看到，启动，2秒炸了一次，然后4秒炸了一次，然后再2秒，4秒。。循环

**代码分析：**

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

> 首先主线程main方法执行下来，首先执行上面的Timer定时器，2秒后执行内部类MyTimerTask里面的run方法，判断静态变量count的值，执行另外一个定时器，设定时间为4秒，然后4秒后定时器继续执行MyTimerTask里面的run方法，根据静态变量的值，设定时间为2秒后执行，如此循环。

### **实现方式二：使用两个定时任务，交替调用执行** ###

package test01;
    
    import java.util.Date;
    import java.util.Timer;
    import java.util.TimerTask;
    
    public class TraditionalTimerTest { 
    
        // 定时任务1，在里面调用任务2，设定4秒
        class MyTimerTask1 extends TimerTask{
    
            @Override
            public void run() {
                System.out.println("boom!");
                new Timer().schedule(new MyTimerTask2(), 4000);
            }
    
        }
    
        // 定时任务2，在里面调用任务1，设定2秒
        class MyTimerTask2 extends TimerTask{
    
            @Override
            public void run() {
                System.out.println("boom!");
                new Timer().schedule(new MyTimerTask1(),2000);
            }
    
        }
    
        public static void main(String[] args) {
    
            new Timer().schedule(new TraditionalTimerTest(). new MyTimerTask1(), 2000);
    
            while(true){
                System.out.println(new Date().getSeconds());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
    
        }
    }

输出结果：  
![这里写图片描述][20160419133324825]  
当然这里的结果跟方式一是一样的，实现方式只是思考的方式不一样而已。

## **示例应用场景4：设定一个定时器，在某一个时间点执行，之后每隔2秒执行** ##

package test01;
    
    import java.util.Calendar;
    import java.util.Date;
    import java.util.Timer;
    import java.util.TimerTask;
    
    public class TraditionalTimerTest { 
    
        public static void main(String[] args) {
            // 2016.04.19 13:43:30
            Calendar cal = Calendar.getInstance();
            cal.set(2016, 03, 19, 13, 43 ,30);
            System.out.println(cal.getTime());
    
            new Timer().schedule(new TimerTask() {
    
                @Override
                public void run() {
                    System.out.println("boom!");
                }
            }, cal.getTime(),2000);
    
            while(true){
                System.out.println(new Date().getSeconds());
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
    
        }
    }

这里设定2016.04.19 13:43:30 执行，然后每隔2秒执行一次  
输出结果：  
![这里写图片描述][20160419134533373]  
分析：其实还是一个API的问题

> **另外**，类似这种需求其实可以用**Quartz**这个框架去用，比这个方便多了。

[20160419121622838]: /images/20220724/238c7475f1734ed4abb3927bd18ca93f.png
[20160419131941832]: /images/20220724/6a582e6d3ccc4617ae6e34bc1e555c29.png
[20160419133324825]: /images/20220724/9c486e70e0324d12be3a6782b7b096f7.png
[20160419134533373]: /images/20220724/031b6e1a9bd24730b233325de7138f87.png