定时器详解

定时器：Timer类

常用方法方法：

1.schedule(TimeTask timetask,long delay,(long period)):

TimeTask：实现了Runnable类，实现时需要重写run方法

delay：表示延迟多少(decay)后开始执行任务，单位是毫秒，这个参数也可以是日期(Date)

period：周期时间，表示定时器循环执行任务之间的间隔时间，时间是毫秒

如果没有period参数，那么就只执行一次任务内容

2.scheduleAtFixedRate(TimeTask timetask,long delay,long period):

参数和schedule的参数相同，其作用为定时器设置循环执行的内容，第一次执行内容的延迟时间，循环的周期时间。可以看出schedule方法的功能其实已经包括这个方法了

3.cancel():关闭计时器

---

schedule(TimeTask timetask,long delay)

public static void main(String[] args) {
        System.out.println("任务三秒后开启");
        
        Timer t = new Timer();
        //定时执行任务 表示几秒后执行run方法里面的内容
        t.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("任务开启");
            }
        },3000);
    }

---

schedule(TimeTask timetask,long delay,long period):

 public static void main(String[] args) {
        System.out.println("任务三秒后开启");

        Timer t = new Timer();
        //定时执行任务 表示几秒后执行run方法里面的内容
        t.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("开始以1秒的时间间隔循环执行任务");
            }
        },2000,1000);
    }

---

scheduleAtFixedRate(TimeTask timetask,long delay,long period):

 public static void main(String[] args) {
        System.out.println("任务两秒后开启");

        Timer t = new Timer();
        //定时执行任务 表示几秒后执行run方法里面的内容
        t.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("任务开启");
            }
        },2000);

        t.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                System.out.println("开始循环任务(间隔1s)");
            }
        },2000,1000);
    }

---

指定定时器执行固定个任务后结束

public static void main(String[] args) {
        Timer t = new Timer();
        int timeCount = 5;
        long delay = 1000;
        long period = 1000;

        t.schedule(new TimerTask() {
            int count = 1;
            @Override
            public void run() {
                if(count >= timeCount){
                    t.cancel();
                }
                System.out.println("执行任务:"+count);
                count++;
            }
        },delay,period);
    }

模拟实现定时器

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.PriorityBlockingQueue;

class Task implements Comparable<Task>{
    //这个类用来描述任务的
    private Runnable runnable;

    //执行的任务时间
    private long time; //time + System.currentTimeMillis()

    public Task(Runnable runnable,long time){
        this.runnable = runnable;
        this.time = time;
    }

    public long getTime(){
        return time ;
    }

    public void run() {
        runnable.run();
    }

    //比较规则 执行时间在前的先执行
    @Override
    public int compareTo(Task o) {
        return (int)(this.time - o.time);
    }
}
public class MyTimer{
    //一个阻塞队列
    private BlockingQueue<Task> queue = new PriorityBlockingQueue<>();

    //扫描线程
    private Thread t = null;

    public MyTimer(){
            t = new Thread(() -> {
                while(true) {
                    try {
                        Task task = queue.take();
                        if (task.getTime() > System.currentTimeMillis()) {
                            //还没到时间
                            queue.put(task);
                        } else {
                            //执行任务
                            task.run();
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
            t.start();
        }

    public void schedule(Runnable runnable,long time) throws InterruptedException {
        //在这一步加System.currentTimeMillis() 不能在getTime方法中加，不然就会一直大于System.currentTimeMillis()
        Task task = new Task(runnable, time+System.currentTimeMillis());
        queue.put(task);
    }

    public static void main(String[] args) throws InterruptedException {
        MyTimer m = new MyTimer();
        m.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("这是任务1");
            }
        },2000);

        m.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("这是任务2");
            }
        },1000);
    }
}

---

问题：

1.忙等

假设此时时间是上午9点，第一个任务的时间是上午10点，那么在这一个小时内，程序会一直重复执行一个代码：

 Task task = queue.take();
 if (task.getTime() > System.currentTimeMillis()) {
     //还没到时间
     queue.put(task);
 }

这行代码可能会循环个非常多亿次，且别忘了，优先级队列的底层是用堆实现的，每当我们取出一个元素又出现插入时，根据堆的调整，此元素又会在堆顶，而每一层调整都是有开销的，故这一时间段的开销是重复且多余的，所以我们就等一次，等堆顶任务执行时间与当前时间的差值就可，修改代码：

 Task task = queue.take();
 if (task.getTime() > System.currentTimeMillis()){
     //还没到时间
     queue.put(task);
     Thread.sleep(task.getTime() - System.currentTimeMillis());

---

大伙们是不是觉得此时的代码就已经完美了？！！

然而并不是！ 我们并不能使用sleep休眠来休眠两时间差

试想一下，如果咱们休眠的时候突然插进来了一个上午9.30执行的任务，那么这个任务就不会被执行到！故使用带参版本的wait()方法才是最好的选择

再次修改代码：

 if (task.getTime() > System.currentTimeMillis()){
     //还没到时间
     queue.put(task);
     synchronized (this){
        this.wait(task.getTime() - System.currentTimeMillis());
     }


 public void schedule(Runnable runnable,long time) throws InterruptedException {
        Task task = new Task(runnable, time+System.currentTimeMillis());
        queue.put(task);
        //唤醒t线程里的wait操作
        this.notify();
     }

这个时候代码看起来是不是似乎万无一失了已经！

but，我们来考虑一个极端极端极端极端的情况

---

2.极端情况

 if (task.getTime() > System.currentTimeMillis()){
     //还没到时间
     queue.put(task);
     synchronized (this){
        this.wait(task.getTime() - System.currentTimeMillis());
     }

如果线程1在执行到queue.put(task)时，恰好被调度走了，此时另一个线程调用schedule方法，且如果当线程2的任务时间小于线程1的任务时间时，此时线程2的任务就不会执行到。因为线程2的notify没作用，线程1都还没有执行到wait方法，但线程1重新执行时，此时的时间差已经是固定了的，但是这个时间差要大于线程2任务执行的时间，故线程2就会被“极端”地错过

---

完美代码

加大锁的力度：造成此极端情况的原因即为:take和wait是多步操作，非原子性

public MyTimer(){
            t = new Thread(() -> {
                while(true) {
                    synchronized (this){
                        try {
                            Task task = queue.take();
                            if (task.getTime() > System.currentTimeMillis()) {
                                //还没到时间
                                queue.put(task);
                                this.wait(task.getTime() - System.currentTimeMillis());
                            } else {
                                //执行任务
                                task.run();
                            }
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            });
            t.start();
        }