Java Academy · 课时

使用 ScheduledExecutorService 执行重复任务

Q: 「使用 ScheduledExecutorService 执行重复任务」这节课中我会学到什么？

按固定速率或固定延迟安排任务，用于轮询和后台维护工作 你通过在浏览器中直接运行的动手代码来练习 Java Academy，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

按固定速率或固定延迟安排任务，用于轮询和后台维护工作

使用 ScheduledExecutorService 执行重复任务 是 CoddyKit 上的免费 Java Academy 课时。这是第 4 节课，共 4 节。你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。这是 Java Academy 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Java Academy 课程共包含 4 节课。

为什么使用 ScheduledExecutorService

ScheduledExecutorService 扩展了 ExecutorService，以支持任务调度。它使用线程池作为基础，并提供安全的异常处理，用来替代旧版的 Timer/TimerTask 类。

import java.util.concurrent.*;

ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(2);

// One-shot delay
scheduler.schedule(
    () -> System.out.println("Runs once after 3 seconds"),
    3, TimeUnit.SECONDS
);

// Don't forget to shut down eventually:
// scheduler.shutdown();

schedule：一次性延迟

schedule(task, delay, unit) 会在指定延迟后运行一次任务。Runnable 和 Callable 都可以使用它：

ScheduledExecutorService s = Executors.newScheduledThreadPool(1);

// Runnable:
ScheduledFuture<?> sf1 = s.schedule(
    () -> System.out.println("Runnable fired!"), 2, TimeUnit.SECONDS);

// Callable:
ScheduledFuture<Integer> sf2 = s.schedule(
    () -> { System.out.println("Callable fired!"); return 42; },
    2, TimeUnit.SECONDS);

System.out.println(sf2.get()); // 42 (after 2 seconds)

scheduleAtFixedRate

scheduleAtFixedRate(task, initialDelay, period, unit) 会以固定频率重复运行任务。如果任务耗时超过执行周期，则下一次执行会在本次完成后立即开始（不会重叠执行）。

ScheduledExecutorService s = Executors.newScheduledThreadPool(1);
AtomicInteger count = new AtomicInteger();

ScheduledFuture<?> sf = s.scheduleAtFixedRate(
    () -> System.out.println("Tick " + count.incrementAndGet()),
    0,   // initial delay
    1,   // period
    TimeUnit.SECONDS
);

Thread.sleep(5000);
sf.cancel(false); // stop after 5 ticks
s.shutdown();

scheduleWithFixedDelay

scheduleWithFixedDelay(task, initialDelay, delay, unit) 会在每次任务完成后等待指定的延迟时间，然后再开始下一次执行。它适合任务持续时间不固定的轮询。

s.scheduleWithFixedDelay(
    () -> {
        System.out.println("Polling... " + Instant.now());
        // variable-length polling task
    },
    0,  // no initial delay
    5,  // 5-second gap AFTER each completion
    TimeUnit.SECONDS
);
// Next execution = task end + 5 seconds (not task start)

固定频率与固定延迟

主要区别：

scheduleAtFixedRate：下一次开始时间 = 上一次开始时间 + 周期（时间不会逐渐漂移）
scheduleWithFixedDelay：下一次开始时间 = 上一次完成时间 + 延迟（执行之间保证存在间隔）

心跳任务使用 fixedRate；任务持续时间不固定的轮询使用 fixedDelay。

ScheduledFuture：取消任务

schedule/scheduleAtFixedRate/scheduleWithFixedDelay 会返回一个 ScheduledFuture。调用 cancel(false) 可以停止将来的执行，但不会中断当前正在运行的任务：

ScheduledFuture<?> sf = scheduler.scheduleAtFixedRate(
    () -> System.out.println("Heartbeat"), 0, 1, TimeUnit.SECONDS);

// Cancel after 5 seconds
scheduler.schedule(() -> sf.cancel(false), 5, TimeUnit.SECONDS);

处理定时任务中的异常

如果定时任务抛出未捕获的异常，调度器会静默停止重复执行，之后不再执行。请务必使用 try-catch 包装任务：

scheduler.scheduleAtFixedRate(() -> {
    try {
        // risky work
        if (Math.random() < 0.3) throw new RuntimeException("transient");
        System.out.println("Success");
    } catch (Exception e) {
        System.err.println("Task error: " + e.getMessage());
        // task continues to run on next interval
    }
}, 0, 2, TimeUnit.SECONDS);

实际应用：刷新缓存

使用定时任务定期刷新缓存：

class PriceCache {
    private volatile Map<String, Double> prices = new HashMap<>();
    
    PriceCache(ScheduledExecutorService scheduler) {
        scheduler.scheduleAtFixedRate(this::refresh, 0, 30, TimeUnit.SECONDS);
    }
    
    private void refresh() {
        System.out.println("Refreshing prices...");
        // prices = fetchFromDatabase();
    }
    
    Double getPrice(String symbol) { return prices.get(symbol); }
}

实际应用：带退避的重试

使用定时任务实现指数退避重试：

void retryWithBackoff(Runnable task, int maxRetries, ScheduledExecutorService s) {
    AtomicInteger attempts = new AtomicInteger(0);
    long[] delay = {1}; // seconds
    
    Runnable wrapper = new Runnable() {
        public void run() {
            try {
                task.run();
            } catch (Exception e) {
                int n = attempts.incrementAndGet();
                if (n < maxRetries) {
                    delay[0] *= 2;
                    s.schedule(this, delay[0], TimeUnit.SECONDS);
                } else System.err.println("Max retries reached");
            }
        }
    };
    s.execute(wrapper);
}

监控：getDelay 与 getQueue

检查调度器的状态：

ScheduledFuture<?> sf = scheduler.schedule(() -> {}, 10, TimeUnit.SECONDS);
System.out.println("Delay remaining: " + sf.getDelay(TimeUnit.SECONDS) + "s");

// ThreadPoolExecutor provides queue inspection:
if (scheduler instanceof ScheduledThreadPoolExecutor ste) {
    System.out.println("Queue size: " + ste.getQueue().size());
}

关闭与排空

关闭时，请决定是否仍应运行定时任务：

ScheduledThreadPoolExecutor ste = (ScheduledThreadPoolExecutor)
    Executors.newScheduledThreadPool(2);

// Cancel scheduled tasks on shutdown (default: false = they run)
ste.setExecuteExistingDelayedTasksAfterShutdownPolicy(false);
ste.setContinueExistingPeriodicTasksAfterShutdownPolicy(false);

ste.shutdown();

快速检查

使用 scheduleAtFixedRate(..., 1, TimeUnit.SECONDS) 调度的任务需要 3 秒才能完成。调度器会如何处理它？

回顾：ScheduledExecutorService

关键要点：

schedule() — 带延迟执行一次
scheduleAtFixedRate() — 无漂移计时（从开始到开始）
scheduleWithFixedDelay() — 保证间隔（从完成到开始）
未捕获的异常会静默地停止重复任务 — 请始终使用 try-catch 包裹
使用 ScheduledFuture.cancel(假) 取消

常见问题解答

「使用 ScheduledExecutorService 执行重复任务」课时是免费的吗？

是的 — 「使用 ScheduledExecutorService 执行重复任务」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Java Academy 课程的其余内容，请升级到 CoddyKit PRO。 Java Academy 课程共包含 4 节课。

「使用 ScheduledExecutorService 执行重复任务」这节课中我会学到什么？

按固定速率或固定延迟安排任务，用于轮询和后台维护工作你通过在浏览器中直接运行的动手代码来练习 Java Academy，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 Java Academy 需要有经验吗？

无需任何先前经验。CoddyKit 上的 Java Academy 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。这是第 4 节课，共 4 节。

「使用 ScheduledExecutorService 执行重复任务」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 Java Academy 课中编写并运行代码吗？

能。每节 Java Academy 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

← 返回 Java Academy