Java 定时器原理与自定义实现

2. 注册任务

Timer 类负责维护队列并提供 schedule 方法。

class MyTimer {
    private PriorityBlockingQueue<MyTask> queue = new PriorityBlockingQueue<>();

    public void schedule(Runnable runnable, long after) {
        MyTask myTask = new MyTask(runnable, System.currentTimeMillis() + after);
        try {
            queue.put(myTask);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

3. 扫描线程与 CPU 消耗问题

接下来是核心的扫描线程。最直观的做法是死循环不断检查队首元素。

Thread scan = new Thread(() -> {
    while (true) {
        try {
            MyTask myTask = queue.take();
            if (System.currentTimeMillis() < myTask.getTime()) {
                // 时间未到，放回队列
                queue.put(myTask);
            } else {
                // 时间到了，执行任务
                myTask.run();
            }
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
});
scan.start();

这里有个严重的问题：while(true) 循环速度极快，会导致 CPU 空转浪费资源。

4. 引入 wait/notify 优化

为了解决轮询问题，我们可以让线程在等待期间休眠。利用 wait 方法，让线程在特定时间内暂停。

修改后的逻辑：如果时间未到，计算剩余时间并调用 wait；如果时间到，执行任务。

public void schedule(Runnable runnable, long after) {
    MyTask myTask = new MyTask(runnable, System.currentTimeMillis() + after);
    try {
        queue.put(myTask);
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
    synchronized (this) {
        this.notify();
    }
}

// 扫描线程
Thread scan = new Thread(() -> {
    while (true) {
        try {
            MyTask myTask = queue.take();
            if (System.currentTimeMillis() < myTask.getTime()) {
                queue.put(myTask);
                synchronized (this) {
                    this.wait(myTask.getTime() - System.currentTimeMillis());
                }
            } else {
                myTask.run();
            }
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
});
scan.start();

5. 解决竞态条件

此时代码仍存在隐患。假设当前时间是 13:00，队首任务需 14:00 执行。线程进入 wait 前被挂起，此时另一个线程插入一个 13:30 的任务。由于 take() 和 wait() 不是原子操作，新任务可能无法及时唤醒旧线程，导致 13:30 的任务错过执行时机。

解决方案是在整个检查过程中加锁，保证原子性。

Thread scan = new Thread(() -> {
    while (true) {
        synchronized (this) {
            try {
                MyTask myTask = queue.take();
                if (System.currentTimeMillis() < myTask.getTime()) {
                    queue.put(myTask);
                    this.wait(myTask.getTime() - System.currentTimeMillis());
                } else {
                    myTask.run();
                }
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
});
scan.start();

完整代码示例

将上述逻辑整合，我们得到一个完整的简易定时器实现。

class MyTask implements Comparable<MyTask> {
    private Runnable runnable;
    private long time;

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

    public long getTime() {
        return time;
    }

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

    @Override
    public int compareTo(MyTask o) {
        return Long.compare(this.time, o.time);
    }
}

class MyTimer {
    private Thread scan;
    private PriorityBlockingQueue<MyTask> queue = new PriorityBlockingQueue<>();

    public void schedule(Runnable runnable, long after) {
        MyTask myTask = new MyTask(runnable, System.currentTimeMillis() + after);
        try {
            queue.put(myTask);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        synchronized (this) {
            this.notify();
        }
    }

    public MyTimer() {
        scan = new Thread(() -> {
            while (true) {
                synchronized (this) {
                    try {
                        MyTask myTask = queue.take();
                        if (System.currentTimeMillis() < myTask.getTime()) {
                            queue.put(myTask);
                            this.wait(myTask.getTime() - System.currentTimeMillis());
                        } else {
                            myTask.run();
                        }
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        });
        scan.start();
    }
}

public class ThreadDemo8 {
    public static void main(String[] args) {
        MyTimer myTimer = new MyTimer();
        myTimer.schedule(() -> System.out.println("hello,1"), 300);
        myTimer.schedule(() -> System.out.println("hello,2"), 600);
    }
}

通过这种方式，我们不仅实现了定时功能，还深入理解了 Java 并发工具中队列、锁以及线程协作的基本原理。