【JavaEE】多线程案例-定时器

1. 前言

在生活中，我们肯定遇到过访问某个网站的时候或者加载视频的时候，出现请求超时的现象吧，如果客户端向服务器发送请求，但是没有得到响应该怎么办呢？难道要让我们死等吗？这肯定是不现实的，那么这时候就需要用到我们的定时器。客户端向服务器发送请求，如果超过一段时间没有得到响应，那么定时器就会决定是重新发送请求还是停止请求。在多线程案例中，定时器是一个比较复杂的案例，同时也是比较重要的一个多线程案例。今天我将为大家分享关于定时器知识的分享。

2. 如何使用Java标准库提供的定时器

在 Java 的 util 包下提供了定时器的实现，我们可以直接使用 Java 标准库提供的定时器。

import java.util.Timer;
import java.util.TimerTask;

public class Demo1 {
    
    
    public static void main(String[] args) {
    
    
        Timer timer = new Timer();
        timer.schedule(new TimerTask() {
    
    
            @Override
            public void run() {
    
    
                System.out.println(3000);
            }
        },3000);

        timer.schedule(new TimerTask() {
    
    
            @Override
            public void run() {
    
    
                System.out.println(2000);
            }
        },2000);

        timer.schedule(new TimerTask() {
    
    
            @Override
            public void run() {
    
    
                System.out.println(1000);
            }
        },1000);
        System.out.println("定时器开始");
    }
}

• Timer 类表示定时器类
• 调用 Timer 类的 schedule 方法，将 TimerTask 类添加到定时器内
• TimerTask 类包括了该任务的具体实现内容，以及执行这个任务的时间

delay 表示从调用 schedule 方法开始的多长时间执行这个任务。不管哪个任务先添加的，总是按照时间的从小到大顺序执行。并且仔细观察我们可以发现，当执行完定时器当中的内容的时候，整个线程并没有结束，这是因为 Timer 内部的线程阻止了线程的结束。

3. 如何自己实现一个定时器

3.1 构建 MyTimerTask 任务类

虽然 Java 标准库为我们提供了定时器，但是我们作为初学者，还是需要知道他究竟是如何实现的，我们能自己实现一个计时器对理解定时器作用是非常大的。

class Mytimer {
    
    
    private long time;
    private Runnable runnable;
    public Mytimer(Runnable runnable, long delay) {
    
    
        this.runnable = runnable;
        this.time = System.currentTimeMillis() + delay;
    }
    
    public long getTime() {
    
    
        return this.time;
    }
    
    public Runnable getRunnable() {
    
    
        return this.runnable;
    }
}

先创建一个 MyTimerTask 类用来描述任务的具体内容，包括执行的操作和执行的时间。

3.2 使用优先级队列来存储多个任务

当创建一个 MyTimerTask 类用来描述具体的内容之后，又该用什么来存储这多个 MyTimerTask 任务呢？因为它是按照时间的先后顺序执行的，时间近的任务优先级高，那么这样的话，我们就可以使用优先级队列这个数据结构来存储 MyTimerTask 类，并且创建的小根堆，时间最接近的放在堆顶。

	PriorityQueue<MyTimerTask> queue = new PriorityQueue<>();

3.3 实现 schedule 方法来添加任务

当调用 schedule 方法的时候，就调用 PriorityQueue 的 offer 方法将任务添加到优先级队列中。

	public void schedule(MyTimerTask myTimerTask) {
    
    
        queue.offer(myTimerTask);
    }

3.4 实现 Timer 类当中的扫描线程和具体细节

Timer 线程中需要一个扫描线程来看堆顶任务是否该执行了。当优先级队列为空的时候，需要该线程进入等待状态，直到调用 schedule 方法向队列中添加任务的时候才唤醒该线程。所以我们前面的 schedule 方法就需要稍作调整。

	private static Object locker = new Object();

    public void schedule(MyTimerTask myTimerTask) {
    
    
        synchronized (locker) {
    
    
            queue.offer(myTimerTask);
            locker.notify();
        }
    }

    public MyTimer() {
    
    
        Thread t = new Thread(() -> {
    
    
            while (true) {
    
    
                try {
    
    
                    synchronized (locker) {
    
    
                    	//通常线程被唤醒之后的判断不使用if，
                    	//而是使用while循环，因为唤醒线程的方法不止有notify
                    	//interrupt方法也可以唤醒处于等待状态的线程
                    	//当处于等待状态的线程是因为interrupt方法唤醒的时候
                    	//就说明没有执行schedule方法，此时queue中还是为空的
                        while (queue.isEmpty()) {
    
    
                            locker.wait();
                        }
                    }
                } catch (Exception e) {
    
    
                    e.printStackTrace();
                }
            }
        });
    }

这里在调用 schedule 方法的好处不止有唤醒当堆为空时的等待状态，还有一些好处，我们在后面遇到的时候为大家讲解。

当堆不为空的时候，就要判断堆顶的任务是否到了需要执行的时间，如果到了需要执行的时间，就执行，没到则不需要做。

	public MyTimer() {
    
    
        Thread t = new Thread(() -> {
    
    
            while (true) {
    
    
                try {
    
    
                    synchronized (locker) {
    
    
                        while (queue.isEmpty()) {
    
    
                            locker.wait();
                        }

                        MyTimerTask task = queue.peek();
                        if (curTime >= task.getTime()) {
    
    
                            task.getRunnable().run();
                            queue.poll();
                        }else {
    
    
                            ;
                        }
                    }
                } catch (Exception e) {
    
    
                    e.printStackTrace();
                }
            }
        });
        t.start();
    }

当我们运行这个计时器的时候，看看结果如何

import java.util.PriorityQueue;

class MyTimerTask {
    
    
    private long time;
    private Runnable runnable;
    public MyTimerTask(Runnable runnable, long delay) {
    
    
        this.runnable = runnable;
        this.time = System.currentTimeMillis() + delay;
    }

    public long getTime() {
    
    
        return this.time;
    }

    public Runnable getRunnable() {
    
    
        return this.runnable;
    }
}

class MyTimer {
    
    
    PriorityQueue<MyTimerTask> queue = new PriorityQueue<>();
    private static Object locker = new Object();

    public void schedule(Runnable runnable, long delay) {
    
    
        synchronized (locker) {
    
    
            queue.offer(new MyTimerTask(runnable,delay));
            locker.notify();
        }
    }

    public MyTimer() {
    
    
        Thread t = new Thread(() -> {
    
    
            while (true) {
    
    
                try {
    
    
                    synchronized (locker) {
    
    
                        while (queue.isEmpty()) {
    
    
                            locker.wait();
                        }

                        MyTimerTask task = queue.peek();
                        long curTime = System.currentTimeMillis();
                        if (curTime >= task.getTime()) {
    
    
                            task.getRunnable().run();
                            queue.poll();
                        }else {
    
    
                            ;
                        }
                    }
                } catch (Exception e) {
    
    
                    e.printStackTrace();
                }
            }
        });
        t.start();
    }
}

public class Demo3 {
    
    
    public static void main(String[] args) {
    
    
        MyTimer myTimer = new MyTimer();
        myTimer.schedule(new Runnable() {
    
    
            @Override
            public void run() {
    
    
                System.out.println(3000);
            }
        },3000);

        myTimer.schedule(new Runnable() {
    
    
            @Override
            public void run() {
    
    
                System.out.println(2000);
            }
        },2000);

        myTimer.schedule(new Runnable() {
    
    
            @Override
            public void run() {
    
    
                System.out.println(1000);
            }
        },1000);

        System.out.println("计时器开始");
    }
}

这里为什么会报错呢？

3.5 定时器的修改及优化

这里我们遗漏了一个细节，前面学习优先级队列的时候，我们知道优先级队列当中的元素必须是可比较的元素，跟 TreeMap 和 TreeSet 是一样的，但是 MyTimerTask 是一个类，类与类之间是不能够进行大小的比较的，所以我们需要重写 MyTimerTask 中的 compareTo 方法来指明比较方式。

class MyTimerTask implements Comparable<MyTimerTask>{
    
    
    private long time;
    private Runnable runnable;
    public MyTimerTask(Runnable runnable, long delay) {
    
    
        this.runnable = runnable;
        this.time = System.currentTimeMillis() + delay;
    }

    public long getTime() {
    
    
        return this.time;
    }

    public Runnable getRunnable() {
    
    
        return this.runnable;
    }

    @Override
    public int compareTo(MyTimerTask o) {
    
    
        return (int) (this.time - o.time);
    }
}

当进行这样的修改之后，堆中的元素就是可比较的了。写到这里其实功能就已经实现了，但是呢？还需要做出优化：当堆顶元素未到达执行时间的时候，难道真的什么都不用做吗？如果什么都不做的话，那么代码就会回到上面的while循环部分，继续判断堆顶元素是否到达了执行时间，因为计算机的执行速度很快，那么在这个到达执行堆顶元素任务的时间之内又进行了上万次判断，那么这种情况就叫做忙等。要想解决这个忙等问题，当判断未到达堆顶元素的执行时间的时候，我们让该线程等待一定的时间，不让这个线程继续循环判断。

	public MyTimer() {
    
    
        Thread t = new Thread(() -> {
    
    
            while (true) {
    
    
                try {
    
    
                    synchronized (locker) {
    
    
                        while (queue.isEmpty()) {
    
    
                            locker.wait();
                        }

                        MyTimerTask task = queue.peek();
                        long curTime = System.currentTimeMillis();
                        if (curTime >= task.getTime()) {
    
    
                            task.getRunnable().run();
                            queue.poll();
                        }else {
    
    
                            locker.wait(task.getTime() - curTime);
                        }
                    }
                } catch (Exception e) {
    
    
                    e.printStackTrace();
                }
            }
        });
        t.start();
    }

到这里就可以说说前面 schedule 方法的 notify 方法的又一个好处：如果在 Timer 计时器在等待执行堆顶元素的过程中，又加入了一个任务，并且这个任务的执行时间先于之前堆顶元素任务的执行时间，那么当添加完成之后就会唤醒 Timer 计时器的等待状态，然后将这个刚加入的任务放入堆顶，并且下一个执行该任务。

4. 计时器完整代码

import java.util.PriorityQueue;

class MyTimerTask implements Comparable<MyTimerTask>{
    
    
    private long time;
    private Runnable runnable;
    public MyTimerTask(Runnable runnable, long delay) {
    
    
        this.runnable = runnable;
        this.time = System.currentTimeMillis() + delay;
    }

    public long getTime() {
    
    
        return this.time;
    }

    public Runnable getRunnable() {
    
    
        return this.runnable;
    }

    @Override
    public int compareTo(MyTimerTask o) {
    
    
        return (int) (this.time - o.time);
    }
}

class MyTimer {
    
    
    PriorityQueue<MyTimerTask> queue = new PriorityQueue<>();
    private static Object locker = new Object();

    public void schedule(Runnable runnable, long delay) {
    
    
        synchronized (locker) {
    
    
            queue.offer(new MyTimerTask(runnable,delay));
            locker.notify();
        }
    }

    public MyTimer() {
    
    
        Thread t = new Thread(() -> {
    
    
            while (true) {
    
    
                try {
    
    
                    synchronized (locker) {
    
    
                        while (queue.isEmpty()) {
    
    
                            locker.wait();
                        }

                        MyTimerTask task = queue.peek();
                        long curTime = System.currentTimeMillis();
                        if (curTime >= task.getTime()) {
    
    
                            task.getRunnable().run();
                            queue.poll();
                        }else {
    
    
                            locker.wait(task.getTime() - curTime);
                        }
                    }
                } catch (Exception e) {
    
    
                    e.printStackTrace();
                }
            }
        });
        t.start();
    }
}

public class Demo3 {
    
    
    public static void main(String[] args) {
    
    
        MyTimer myTimer = new MyTimer();
        myTimer.schedule(new Runnable() {
    
    
            @Override
            public void run() {
    
    
                System.out.println(3000);
            }
        },3000);

        myTimer.schedule(new Runnable() {
    
    
            @Override
            public void run() {
    
    
                System.out.println(2000);
            }
        },2000);

        myTimer.schedule(new Runnable() {
    
    
            @Override
            public void run() {
    
    
                System.out.println(1000);
            }
        },1000);

        System.out.println("计时器开始");
    }
}