如何在 Java 中利用 while 循环实现一个简单的基于时间轮算法的定时任务调度流程

数码系统

相机 win10

测评 win11

手机智车

华为 Tesla

小米理想

苹果蔚来

游戏软件

LOL 抖音

原神微信

当前位置：首页

编程语言

如何在 Java 中利用 while 循环实现一个简单的基于时间轮算法的定时任务调度流程

热心网友时间：2026-05-01

转载

# 如何在 Ja va 中利用 while 循环实现一个简单的基于时间轮算法的定时任务调度流程

可行但仅适用于学习、嵌入式或教学场景；生产环境应优先选用 HashedWheelTimer、ScheduledThreadPoolExecutor 或 Quartz。

在 Ja va 中，用 while 循环模拟时间轮（timing wheel）调度器是可行的。不过，这里必须划个重点：这种实现方式更适合用来理解原理、用于嵌入式轻量场景或者教学演示。如果是在真实的生产环境中，更稳妥的选择是直接使用 HashedWheelTimer（来自 Netty）、ScheduledThreadPoolExecutor 或是功能更全面的 Quartz。

免费影视、动漫、音乐、游戏、小说资源长期稳定更新！ 👉 点此立即查看 👈

如何在 Ja va 中利用 while 循环实现一个简单的基于时间轮算法的定时任务调度流程

理解时间轮的核心结构

时间轮算法的核心，并不是去“实时计算下次执行时间”。它的巧妙之处在于，把时间流切分成一个个固定的刻度（我们称之为 tick），每个刻度都对应着一个任务槽（bucket）。任务会根据其延迟时间，被映射到对应的槽位里。主循环每前进一个 tick，就检查当前槽位，并触发其中所有的任务。

这里有几个关键参数需要把握：

tickDuration：每个 tick 代表多少毫秒（例如 100ms）。
ticksPerWheel：时间轮一圈总共有多少格（例如 64 格）。那么，这个时间轮能处理的最大延迟时间跨度就是 tickDuration × ticksPerWheel。
currentTime：当前轮次的基准时间（毫秒级，通常会对齐到 tickDuration 的整数倍）。

用 while 实现单层时间轮主循环

下面是一个简化但可运行的单层时间轮调度器骨架。为了聚焦于核心流程，它暂时没有处理线程安全、任务过期重试等复杂情况。

public class SimpleTimingWheel {
    private final long tickDuration;     // 例如 100ms
    private final int ticksPerWheel;     // 例如 64
    private final List[] wheel;
    private volatile long currentTime;   // 当前 tick 开始时间（毫秒）

    @SuppressWarnings("unchecked")
    public SimpleTimingWheel(long tickDuration, int ticksPerWheel) {
        this.tickDuration = tickDuration;
        this.ticksPerWheel = ticksPerWheel;
        this.wheel = new List[ticksPerWheel];
        for (int i = 0; i < ticksPerWheel; i++) {
            this.wheel[i] = new ArrayList<>();
        }
        // 初始化当前时间，对齐到最近的 tick 边界
        this.currentTime = System.currentTimeMillis() - (System.currentTimeMillis() % tickDuration);
    }

    // 添加延迟任务（此实现仅支持延迟时间小于一圈总时长的任务）
    public void addTask(Runnable task, long delayMs) {
        if (delayMs < 0 || delayMs >= tickDuration * ticksPerWheel) {
            throw new IllegalArgumentException("Delay out of range");
        }
        long expiration = System.currentTimeMillis() + delayMs;
        long tick = (expiration - currentTime) / tickDuration;
        int idx = (int) (tick % ticksPerWheel);
        wheel[idx].add(task);
    }

    // 主循环：持续推进时间，每 tick 执行一次
    public void start() {
        Thread t = new Thread(() -> {
            while (!Thread.currentThread().isInterrupted()) {
                long now = System.currentTimeMillis();
                long expectedTime = currentTime + tickDuration;

                // 等待到下一个 tick 的开始时刻（避免 busy-wait）
                if (now < expectedTime) {
                    try {
                        Thread.sleep(expectedTime - now);
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                        return;
                    }
                }

                // 更新 currentTime（严格对齐 tick 边界）
                currentTime = expectedTime;

                // 触发当前 tick 对应槽位中的所有任务
                // 注意：这里为了简化没有处理异常，实际应用中需要在 task.run() 外包裹 try-catch
                int idx = (int) ((currentTime / tickDuration) % ticksPerWheel);
                List tasks = wheel[idx];
                for (Runnable task : tasks) {
                    task.run();
                }
                tasks.clear(); // 清空已执行的任务
            }
        });
        t.setDaemon(true);
        t.start();
    }
}

立即学习“Ja va免费学习笔记（深入）”；

使用示例与注意事项

调用方式非常简单：

SimpleTimingWheel wheel = new SimpleTimingWheel(100, 64);
wheel.addTask(() -> System.out.println("Hello at " + System.currentTimeMillis()), 300); // 300ms 后执行
wheel.addTask(() -> System.out.println("World!"), 800); // 800ms 后执行
wheel.start();

// 主线程保持运行（否则 JVM 会退出）
Thread.sleep(2000);

在使用这个简化模型时，有几点需要特别注意：

精度限制：最小的延迟单位就是 tickDuration。比如一个 350ms 的任务，实际上会在第 4 个 tick（400ms）时触发。
单圈限制：上述实现只支持延迟时间小于一圈总时长的任务。如果需要处理更大时间跨度的延迟，就需要升级为多层时间轮（例如小时轮、分钟轮、秒轮组合）。
线程安全：addTask() 方法和主循环可能不在同一个线程中调用，实际应用中需要加锁（比如 synchronized 或 ReentrantLock）或者使用线程安全的集合。
异常隔离：某个任务的执行抛出了异常，不应该中断整个 while 循环。务必在 task.run() 外部包裹 try-catch 进行隔离。