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

定时器的应用

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();
            }
        }

    }
}

输出结果：

示例应用场景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();
            }
        }

    }
}

打印结果：

通过上面的打印结果可以看到，启动，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();
            }
        }

    }
}

输出结果：

当然这里的结果跟方式一是一样的，实现方式只是思考的方式不一样而已。

示例应用场景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秒执行一次
输出结果：

分析：其实还是一个API的问题

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