时间轮算法详解：从原理到 Java 实现

缺点： 如果某个 Slot 上挂了很多'未来圈'的任务，每次指针经过都要遍历链表做减法，消耗 CPU。

方案 B：分层时间轮 (Kafka 策略)

这是 Kafka 和类似操作系统的定时器（Hierarchical Timing Wheel）使用的方式。模拟现实中的 秒针、分针、时针。

• 结构： 多个时间轮层级联。
  • 第 1 层（秒轮）： 20 个槽，每槽 1ms。范围 0-20ms。
  • 第 2 层（分轮）： 20 个槽，每槽 20ms。范围 0-400ms。
  • 第 3 层（时轮）： 20 个槽，每槽 400ms。范围 …
• 流程：
  1. 任务延迟 350ms。超过了第 1 层的范围，放入第 2 层对应的槽位。
  2. 随着时间推移，当第 2 层的指针移动到该任务所在的槽位时，任务并不是立即执行，而是被降级（Flush） 到第 1 层。
  3. 最终由第 1 层触发执行。
• 优点： 不需要遍历链表扣减圈数，所有任务最终都会落入最低层级触发，效率极高（O(1)）。

4. Java 中的典型实现

1. Netty: HashedWheelTimer

这是 Java 生态中最著名的时间轮实现。

• 特点： 单层轮，使用 rounds 解决长延迟。
• 线程模型： 单独的 Worker 线程负责拨动指针（Tick）和执行任务。
• 注意： 因为是单线程处理，如果某个任务执行时间过长，会阻塞后续任务的执行。因此，HashedWheelTimer 中的任务必须是非阻塞、执行极快的（通常是把任务扔到另一个线程池执行）。

代码逻辑简述：

// 计算放到哪个格子
long calculated = timeout.deadline / tickDuration;
timeout.remainingRounds = (calculated - tick) / wheel.length; // 计算圈数
final long stopIndex = calculated % wheel.length;
bucket[stopIndex].add(timeout);

2. Kafka: SystemTimer (Hierarchical)

Kafka 内部为了处理大量的延迟操作（如 DelayedFetch），自己实现了一套分层时间轮。

• 特点： 多层级，基于 DelayQueue 驱动指针。
• 优化： Kafka 为了避免空推进（例如轮子上只有 1ms 和 1 小时后有任务，中间的时间不用傻傻地 tick），它使用了一个 DelayQueue 来管理每个层级时间轮的'下一次到期时间'。只有当有槽位真正到期时，才推进时间指针。

5. 优缺点总结

6. 什么时候该用，什么时候不该用？

❌ 不要用时间轮，如果：

1. 任务量很小（例如几百个）：普通的 ScheduledThreadPoolExecutor 足够了，没必要引入额外复杂度。
2. 要求绝对精准：例如工业控制，要求必须在 1000ms 0 误差执行。时间轮受限于 tickDuration，会有误差（例如 tick=100ms，任务可能在 100ms~199ms 之间被执行）。

✅ 请使用时间轮，如果：

1. 海量连接的心跳检测：例如 IM 系统维护 100 万个长连接，每个连接 60 秒无心跳断开。
2. RPC 调用超时：例如 Dubbo 等待服务响应，设置 3 秒超时。
3. 缓存过期清理：大量的 Key 需要在不同时间过期。

7. 简易代码演示 (概念模型)

这是一个简化的、单层、无圈数逻辑的时间轮概念演示，帮助理解数据结构：

import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class SimpleTimeWheel {
    private final int size;
    private final List<Runnable>[] wheel;
    private int currentPointer = 0;

    public SimpleTimeWheel(int size) {
        this.size = size;
        this.wheel = new LinkedList[size];
        for (int i = 0; i < size; i++) {
            wheel[i] = new LinkedList<>();
        }
        // 启动指针拨动线程 (模拟 Tick)
        Executors.newSingleThreadScheduledExecutor().scheduleAtFixedRate(this::tick, 1, 1, TimeUnit.SECONDS);
    }

    public void addTask(Runnable task, int delaySeconds) {
        // 简单取模，暂不处理多圈情况
        int index = (currentPointer + delaySeconds) % size;
        System.out.println("任务被放入槽位：" + index);
        synchronized (wheel[index]) {
            wheel[index].add(task);
        }
    }

    private void tick() {
        // 移动指针
        currentPointer = (currentPointer + 1) % size;
        System.out.println("Tick... 当前指针：" + currentPointer);
        List<Runnable> slot = wheel[currentPointer];
        synchronized (slot) {
            if (!slot.isEmpty()) {
                // 执行该槽位所有任务
                for (Runnable task : slot) {
                    new Thread(task).start(); // 异步执行，防止阻塞 Tick
                }
                slot.clear(); // 清空槽位
            }
        }
    }
}