Spring中@Scheduled方法内使用Thread.sleep的行为不符问题

你的核心问题是混淆了@Scheduled的调度逻辑和手动线程处理的关系，我们一步步拆解：

为什么你的代码不符合预期？ #

• @Scheduled(fixedRate = RATE_IN_MS)的逻辑是从上一次myMethod启动的时间点开始计时，到了指定间隔就会再次调用myMethod，完全不关心myMethod内部的代码有没有执行完。
• 你在myMethod里开新线程执行method()，然后让调度线程Thread.sleep(RATE_IN_MS)——这其实只是让调度线程休眠，但后台的method()线程已经在独立运行了，调度器依然会按fixedRate的时间间隔触发下一次myMethod调用，自然不会等待method()完成。

解决方案分两种场景： #

场景1：不需要单独线程执行method() #

如果method()本身不需要异步执行（或者你愿意让调度线程等待它完成），直接改用fixedDelay即可：

@Scheduled(fixedDelay = RATE_IN_MS)
public void myMethod() {
    method(); // 直接在调度线程中执行，无需开新线程
}

关键区别：

• fixedRate：固定频率，到点就执行，不管上一次任务是否结束
• fixedDelay：固定延迟，上一次任务完全结束后，再等待指定时间才执行下一次

场景2：必须用新线程执行method() #

如果method()耗时很长，不想阻塞调度线程，那需要手动控制调度逻辑，放弃@Scheduled的自动调度，改用ScheduledExecutorService：

import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

@Component
public class YourScheduler {
    private ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();
    private static final long RATE_IN_MS = 1000; // 替换成你的间隔时间

    @PostConstruct
    public void startScheduler() {
        // 第一次任务立即执行
        scheduler.schedule(this::runTaskCycle, 0, TimeUnit.MILLISECONDS);
    }

    private void runTaskCycle() {
        Thread methodThread = new Thread(() -> method());
        try {
            methodThread.start();
            methodThread.join(); // 等待method()执行完成
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            // 处理中断逻辑
        } finally {
            // method()执行完成后，延迟RATE_IN_MS再调度下一次任务
            scheduler.schedule(this::runTaskCycle, RATE_IN_MS, TimeUnit.MILLISECONDS);
        }
    }

    private void method() {
        // 你的业务逻辑
    }

    @PreDestroy
    public void stopScheduler() {
        scheduler.shutdown();
        try {
            if (!scheduler.awaitTermination(1, TimeUnit.SECONDS)) {
                scheduler.shutdownNow();
            }
        } catch (InterruptedException e) {
            scheduler.shutdownNow();
        }
    }
}

这个方案的核心是：每次等待method()的线程执行完成后，再手动调度下一次任务，完全由你控制计时的起点（method()结束后）。

内容的提问来源于stack exchange，提问作者Roni Koren Kurtberg