1. Java多线程计时器实战：从标准库到自定义实现
作为一名Java开发者，掌握多线程编程是进阶的必经之路。今天我想和大家分享一个非常实用的多线程案例——计时器的实现。这个案例不仅可以帮助理解Java标准库中的Timer类，更能通过自定义实现深入掌握多线程协作的核心机制。
计时器在实际开发中应用广泛，比如定时任务调度、延迟执行、周期性任务等场景。我们将从标准库的使用开始，逐步深入到自定义实现，最后还会分享一些我在实际项目中积累的经验技巧。
2. 标准库Timer类的使用解析
2.1 Timer类基础用法
Java标准库提供了java.util.Timer类来实现简单的计时功能。它的核心用法可以概括为三个要素：
- Timer实例：负责调度任务的执行
- TimerTask实例：封装要执行的任务逻辑
- 延迟时间：指定任务执行的相对时间（毫秒）
下面是一个典型的使用示例：
java复制public static void main(String[] args) {
System.out.println("From now on,after 4s will print a word");
Timer timer = new Timer();
timer.schedule(new TimerTask(){
public void run(){
System.out.println("LOVE");
}
}, 4000);
}
这段代码会在4秒后打印"LOVE"。schedule()方法是Timer类的核心方法之一，它接受一个TimerTask对象和一个延迟时间（毫秒）。
注意：Timer类是单线程的，如果一个任务执行时间过长，会影响后续任务的准时执行。这在生产环境中需要特别注意。
2.2 Timer类的进阶用法
除了简单的延迟执行，Timer类还支持：
- 固定延迟执行（schedule方法重载）
- 固定速率执行（scheduleAtFixedRate方法）
- 取消任务（TimerTask.cancel()）
java复制// 固定延迟执行示例
timer.schedule(new TimerTask() {
public void run() {
System.out.println("Fixed delay task");
}
}, 1000, 2000); // 首次延迟1秒，之后每2秒执行一次
// 固定速率执行示例
timer.scheduleAtFixedRate(new TimerTask() {
public void run() {
System.out.println("Fixed rate task");
}
}, 1000, 2000);
两者的区别在于：
- 固定延迟：保证每次执行之间的时间间隔
- 固定速率：保证执行频率（如果某次执行超时，会立即执行下一次）
3. 自定义计时器实现详解
虽然标准库的Timer类很方便，但了解其内部实现原理对提升多线程编程能力大有裨益。下面我们来一步步实现一个自定义计时器。
3.1 整体设计思路
我们的自定义计时器需要解决几个核心问题：
- 如何存储和管理多个定时任务？
- 如何确保任务按时执行？
- 如何高效处理任务的添加和执行？
解决方案：
- 使用优先级队列（PriorityBlockingQueue）存储任务，按执行时间排序
- 使用单独的Worker线程不断检查并执行到期任务
- 使用wait/notify机制实现高效等待
3.2 核心组件实现
3.2.1 任务队列与同步对象
java复制private PriorityBlockingQueue<Task> queue = new PriorityBlockingQueue<>();
private Object mailBox = new Object();
这里使用了PriorityBlockingQueue，它是一个线程安全的优先级队列，非常适合这种场景。mailBox对象用于线程间的同步协调。
提示：PriorityBlockingQueue要求元素实现Comparable接口或提供Comparator。我们稍后会看到Task类的实现。
3.2.2 Task类实现
Task类是计时器的基本执行单元，封装了要执行的代码和执行时间。
java复制static class Task implements Comparable<Task> {
private Runnable command; // 要执行的任务
private long time; // 绝对执行时间
public Task(Runnable command, long after) {
this.command = command;
// 将相对时间转换为绝对时间
this.time = System.currentTimeMillis() + after;
}
public void run() {
command.run();
}
@Override
public int compareTo(Task o) {
// 按执行时间排序，时间早的优先级高
return (int)(time - o.time);
}
}
关键点：
- 存储的是绝对时间而非相对时间，便于比较
- 实现Comparable接口，使队列能按时间排序
- run()方法委托给传入的Runnable执行
3.2.3 Worker线程实现
Worker线程是计时器的核心执行引擎，负责不断检查并执行到期任务。
java复制class Worker extends Thread {
@Override
public void run() {
while (true) {
try {
Task task = queue.take();
long curTime = System.currentTimeMillis();
if (task.time > curTime) {
// 时间未到，重新放回队列
queue.put(task);
synchronized (mailBox) {
// 精确等待剩余时间
mailBox.wait(task.time - curTime);
}
} else {
// 时间到，执行任务
task.run();
}
} catch (InterruptedException e) {
e.printStackTrace();
break;
}
}
}
}
工作流程：
- 从队列取出最早的任务
- 检查是否到达执行时间
- 如果未到，重新入队并精确等待剩余时间
- 如果已到，立即执行任务
- 循环处理下一个任务
注意：这里使用wait(timeout)而非sleep()，因为前者可以被notify()唤醒，响应新任务的添加。
3.3 计时器接口实现
3.3.1 构造方法
java复制public MyTimer() {
// 启动工作线程
Worker worker = new Worker();
worker.start();
}
构造方法很简单，就是启动Worker线程。
3.3.2 schedule方法
java复制public void schedule(Runnable command, long after) {
Task task = new Task(command, after);
queue.offer(task);
synchronized (mailBox) {
mailBox.notify();
}
}
schedule方法完成以下工作：
- 创建Task对象
- 将任务加入优先级队列
- 通知Worker线程（可能正在等待）
提示：notify()调用是为了唤醒可能正在等待的Worker线程，让它重新检查队列中最新的任务。
4. 关键技术与原理深入
4.1 优先级队列的选择
为什么选择PriorityBlockingQueue？
- 线程安全：无需额外同步
- 优先级：自动按执行时间排序
- 阻塞特性：队列为空时take()会阻塞
4.2 时间处理机制
时间处理有两个关键点：
- 绝对时间存储：避免每次比较都要计算
- 精确等待：使用wait(timeout)而非sleep()
java复制// 错误示例：使用sleep()
while (task.time > System.currentTimeMillis()) {
Thread.sleep(10); // 不精确且低效
}
// 正确做法：使用wait(timeout)
long delay = task.time - System.currentTimeMillis();
if (delay > 0) {
mailBox.wait(delay);
}
4.3 线程同步机制
mailBox对象的作用：
- 提供wait/notify的同步锚点
- 确保新任务添加时能及时唤醒Worker线程
- 避免忙等待（busy waiting）消耗CPU
5. 实战经验与优化建议
5.1 常见问题与解决方案
问题1：任务执行时间过长影响后续任务
解决方案：
- 在Worker线程中使用线程池执行任务
- 或者记录任务超时情况并告警
java复制// 使用线程池执行任务
ExecutorService executor = Executors.newCachedThreadPool();
executor.submit(task::run);
问题2：任务异常导致Worker线程终止
解决方案：
- 捕获任务执行中的所有异常
- 或者为Worker线程设置UncaughtExceptionHandler
java复制try {
task.run();
} catch (Exception e) {
e.printStackTrace(); // 记录日志但不终止线程
}
5.2 性能优化建议
- 批量添加任务时优化notify调用：
java复制public void scheduleAll(List<Runnable> commands, long after) {
synchronized (mailBox) {
for (Runnable cmd : commands) {
queue.offer(new Task(cmd, after));
}
mailBox.notify(); // 只需通知一次
}
}
- 添加取消任务功能：
java复制public boolean cancel(Task task) {
boolean removed = queue.remove(task);
if (removed) {
synchronized (mailBox) {
mailBox.notify();
}
}
return removed;
}
- 添加优雅关闭功能：
java复制public void shutdown() {
worker.interrupt();
}
5.3 生产环境注意事项
- 监控队列大小，防止内存溢出
- 记录任务执行日志，便于排查问题
- 考虑分布式场景下的替代方案（如Quartz、Spring Scheduler）
- 为关键任务添加重试机制
6. 扩展思考与进阶方向
6.1 与ScheduledThreadPoolExecutor比较
Java 5.0引入的ScheduledThreadPoolExecutor提供了更强大的调度功能：
- 基于线程池，支持并发执行
- 更丰富的调度选项
- 更好的异常处理
但在简单场景下，我们的自定义实现更加轻量且易于理解。
6.2 支持周期性任务
可以扩展我们的计时器支持周期性任务：
java复制public void scheduleAtFixedRate(Runnable command, long initialDelay, long period) {
schedule(new Task(() -> {
command.run();
scheduleAtFixedRate(command, period, period);
}, initialDelay));
}
6.3 分布式计时器
在分布式系统中，可以考虑：
- 基于Redis的延迟队列
- 基于消息队列的定时消息
- 专门的调度系统（如XXL-JOB）
7. 总结回顾
通过这个案例，我们不仅学会了如何使用标准库的Timer类，还深入理解了其内部实现原理。自定义计时器的实现涉及多个多线程核心技术：
- 优先级队列的应用
- wait/notify线程协作
- 时间处理与任务调度
- 异常处理与资源管理
在实际项目中，我建议根据具体需求选择方案：
- 简单场景：使用标准库Timer
- 复杂场景：使用ScheduledThreadPoolExecutor
- 特殊需求：考虑自定义实现
最后分享一个实用技巧：在调试多线程程序时，为关键线程设置有意义的名称（如"Timer-Worker"），这样在分析线程转储时会更加方便。