Java定时器之JDK自带的定时器实现方式

既然要详细说说定时器，就由浅入深，先从最简单的说起。
我首先接触到的定时器就是根据线程的Thread.sleep（）方法实现的，最开始学习java的时候，会用这个方法实现一些简单的动画效果，今天就来回顾一下当初的小动画！

1. 利用Thread.sleep();方法实现定时任务

首先 Thread.sleep(times)方法是干嘛的呢，它是用来阻塞当前线程运行的一个方法，按字面意思就是让当前线程睡一会，把CPU资源让给其他线程……你给它传入一个long参数，就是你希望她睡多久的时间值。
随便一提，我旁边的老变态面试新人的时候就喜欢问他们：sleep和wait的区别，请自行百度……
示例代码：

    @Test
    public void threadTimer() throws IOException {
        // 每一秒钟执行一次
        final long timeInterval = 1000;
        Runnable runnable = new Runnable() {
            public void run() {
                while (true) {
                    // ------- code for task to run
                    // ------- 要运行的任务代码
                    System.out.println("Hello, stranger");
                    // ------- ends here
                    try {
                        // sleep()：同步延迟数据，并且会阻塞线程
                        Thread.sleep(timeInterval);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        //创建定时器
        Thread thread = new Thread(runnable);
        //开始执行
        thread.start();
        //阻止进程结束
        System.in.read();
    }

上面这个代码就是利用Thread.sleep实现一秒间隔的定时任务。之前用这种方式实现过动画效果，但是直接用它来做项目级的定时任务有点傻，这种定时器明显的缺点就是没有计算任务执行本身所花的时间。
由于执行任务的线程只有一个，所以如果某个任务的执行时间过长，那么将破坏其他任务的定时精确性。如一个任务每1秒执行一次，而另一个任务执行一次需要5秒，那么如果是固定速率的任务，那么会在5秒这个任务执行完成后连续执行5次，而固定延迟的任务将丢失4次执行。

2. java.util.Timer

相对于业余的Thread.sleep方法，JDK其实直接就给我们提供了简单好用的定时器–Timer
Timer是用于管理在后台执行的延迟任务或周期性任务，其中的任务使用java.util.TimerTask表示。任务的执行方式有两种：

• 按固定延迟执行：即schedule的4个重载方法
• 按固定速率执行：即scheduleAtFixedRate的两个重载方法

分别演示一下：

// 两秒后执行一次任务，且只执行一次
	Timer timer = new Timer();
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("Timer is running");
            }
        }, 2000);

可以看到schedule方法有两个参数，一个是实现了TimerTask的任务参数，另一个就是执行任务的倒计时，一旦倒计时结束，就执行一次任务。
如果想间隔性的执行任务，就要用到scheduleAtFixedRate：

	//表示2秒后开始执行，然后每隔5秒执行一次
	Timer timer = new Timer();
        timer. scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                System.out.println("Timer is running");
            }
        }, 2000, 5000);

Timer是线程安全的，没必要担心线程问题。当然了，Timer的缺点和上面的方式一样，都是单线程执行任务，没有时间间隔的精准度。所以利用线程池来实现定时任务的ScheduledExecutorService 横空出世，因为使用了线程池，提供了良好的约定，以便精准设定执行的时间间隔。我称他为第二代定时器！！

3. ScheduledThreadPoolExecutor

JDK5之后，推荐使用这个类实现定时器。
先写个简单的实例：

		//输入的参数2代表线程池中线程的数量。
        ScheduledThreadPoolExecutor scheduled = new ScheduledThreadPoolExecutor(2);
        scheduled.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                System.out.print("time:");
            }
        }, 0, 40, TimeUnit.MILLISECONDS);
        //0表示首次执行任务的延迟时间，40表示每次执行任务的间隔时间，TimeUnit.MILLISECONDS执行的时间间隔数值单位
        //意思就是：0秒后开始执行，然后每40毫秒都会执行一次任务。

其中可设置的时间单位为：
间隔单位毫秒：TimeUnit.MILLISECONDS
间隔单位秒：TimeUnit.SECONDS
间隔单位分钟：TimeUnit.MINUTES
间隔单位小时：TimeUnit.HOURS
间隔单位天：TimeUnit.DAYS

ScheduledThreadPoolExecutor 同样也提供了如同Timer的scheduled方法，用法和timer的一样，执行一次任务，不再演示。

对比ScheduledThreadPoolExecutor和Timer

下面我们做一个小实验，对比一下ScheduledThreadPoolExecutor和timer在执行任务的时候定时误差。
我们分别同timer和ScheduledThreadPoolExecutor写一个定时任务，都设置为2秒后执行，每秒执行一次。
如下：

    static int index;
    @Test
    public void timer() throws IOException
    {
        final Timer timer = new Timer();
        timer. scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                index++;
                System.out.println("Timer= " + getTimes()+" "  +index);
                try {
                    //模拟任务执行需要2秒的时间
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if(index >=10){
                    timer.cancel();
                    System.out.println("停止了？？？？");
                }
            }
            //2秒后执行，每秒执行一次
        }, 2000, 1000);
        System.in.read();
    }

	static ScheduledThreadPoolExecutor stpe = null;
  @Test
    public void executorTimer() throws IOException
    {
        // TODO code application logic here
        //构造一个ScheduledThreadPoolExecutor对象，并且设置它的容量为5个
        stpe = new ScheduledThreadPoolExecutor(5);
        //隔2秒后开始执行任务，并且在上一次任务开始后隔1秒再执行一次；
        stpe.scheduleWithFixedDelay(new Runnable()
        {
            @Override
            public void run()
            {
                index++;
                System.out.println("executor= " + getTimes()+" "  +index);
                try {
                    //模拟任务执行需要2秒的时间
                    Thread.currentThread().sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if(index >=10){
                    stpe.shutdown();
                    if(stpe.isShutdown()){
                        System.out.println("停止了？？？？");
                    }
                }
            }
        }, 2, 1, TimeUnit.SECONDS);
        //隔6秒后执行一次，但只会执行一次。
//        stpe.schedule(task, 6, TimeUnit.SECONDS);
        System.in.read();
    }

    private static String getTimes() {
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss E");
        Date date = new Date();
        date.setTime(System.currentTimeMillis());
        return format.format(date);
    }

稍微解释一下，上面有两个Test方法，和一个getTimes（返回当前时间，精确到秒）方法，其中timer是用timer实现定时器，executorTimer是用ScheduledThreadPoolExecutor实现定时器。
两个定时器都是两秒后执行，每秒执行一次，共执行十次，任务都是调用getTimers方法获取并打印当前时间，且会有一秒的线程暂停来模拟执行任务需要一秒钟。
那么我们分别运行一下看一下执行结果：
Timer：

Timer= 2020-12-25 00:09:32 Fri 1
Timer= 2020-12-25 00:09:34 Fri 2
Timer= 2020-12-25 00:09:36 Fri 3
Timer= 2020-12-25 00:09:38 Fri 4
Timer= 2020-12-25 00:09:40 Fri 5
Timer= 2020-12-25 00:09:42 Fri 6
Timer= 2020-12-25 00:09:44 Fri 7
Timer= 2020-12-25 00:09:46 Fri 8
Timer= 2020-12-25 00:09:48 Fri 9
Timer= 2020-12-25 00:09:50 Fri 10
停止了？？？？

ScheduledThreadPoolExecutor：

executor= 2020-12-25 00:16:38 Fri 1
executor= 2020-12-25 00:16:41 Fri 2
executor= 2020-12-25 00:16:44 Fri 3
executor= 2020-12-25 00:16:47 Fri 4
executor= 2020-12-25 00:16:50 Fri 5
executor= 2020-12-25 00:16:53 Fri 6
executor= 2020-12-25 00:16:56 Fri 7
executor= 2020-12-25 00:16:59 Fri 8
executor= 2020-12-25 00:17:02 Fri 9
executor= 2020-12-25 00:17:05 Fri 10
停止了？？？？

可以看出来Timer是用了两秒执行一次，而使用了传说中更稳定的ScheduledThreadPoolExecutor却是3秒执行一次，而两者都是设定的每秒执行一次，所以我的测试结果是ScheduledThreadPoolExecutor误差更大……

我会继续查找资料，找一下这个问题出现的原因，然后更新在此。

-----------------------------------------------------------分割线--------------------------------------------------------------------------
根据进一步的查阅和调试，发现之前做的实验本身有问题：
ScheduledThreadPoolExecutor执行定时任务有三种方法：

• schedule 创建并执行在给定延迟后启用的单次操作。
• scheduleAtFixedRate 创建并执行在给定的初始延迟之后，随后以给定的时间段首先启用的周期性动作
• scheduleWithFixedDelay 创建并执行在给定的初始延迟之后首先启用的定期动作，随后在一个执行的终止和下一个执行的开始之间给定的延迟

我上面实验用的是scheduleWithFixedDelay 方法，该方法是任务执行完之后，再计时间隔时间，然后执行下一个任务。上面设置的任务间隔为1秒，每个任务大约花费2秒，所以两次打印间隔三秒。这就能说的通了，所以使用了线程池，提供了良好的约定，以便精准设定执行的时间间隔的那个定时人无方法，其实应该是ScheduledThreadPoolExecutor的scheduleAtFixedRate 吗？

其实并不是我们想的那样scheduleAtFixedRate能够多线程执行任务，ScheduledThreadPoolExecutor比我想的更有趣，下一篇继续为大家揭秘：详解：被人误解的ScheduledThreadPoolExecutor定时器