如何实现每X秒循环依次执行两条Java打印命令？

这里提供两种实用的实现方式，可根据场景选择：

方法一：基础while循环 + Thread.sleep() #

这是最直观的实现方案，用无限循环交替执行两个打印语句，每次执行后调用Thread.sleep()等待指定时长。

public class AlternatePrint {
    public static void main(String[] args) {
        int xSeconds = 3; // 替换为你需要的等待秒数X
        long xMillis = xSeconds * 1000L; // 转换为毫秒，适配sleep的参数要求

        while (true) {
            // 执行第一个打印命令
            System.out.println("something");
            try {
                Thread.sleep(xMillis);
            } catch (InterruptedException e) {
                // 处理线程中断，这里选择恢复中断状态并退出循环，可按需调整
                Thread.currentThread().interrupt();
                break;
            }

            // 执行第二个打印命令
            System.out.println("another thing");
            try {
                Thread.sleep(xMillis);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                break;
            }
        }
    }
}

注意：

• Thread.sleep()会抛出InterruptedException，必须捕获处理，示例中的处理逻辑是通用的中断响应方式。
• 该方案适合简单场景，代码直接易懂。

方法二：使用ScheduledExecutorService（优雅的定时任务方案） #

如果你的应用涉及更多定时任务需求，或不想手动处理线程睡眠的异常，推荐用Java并发包的ScheduledExecutorService实现。

通过调度两个定时任务，分别在0秒和X秒后启动，之后每隔2X秒重复一次，即可实现交替打印的效果：

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class ScheduledAlternatePrint {
    public static void main(String[] args) {
        int xSeconds = 3;
        ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor();

        // 第一个任务：立即执行，之后每隔2X秒重复
        executor.scheduleAtFixedRate(
            () -> System.out.println("something"),
            0,
            2 * xSeconds,
            TimeUnit.SECONDS
        );

        // 第二个任务：延迟X秒后执行，之后每隔2X秒重复
        executor.scheduleAtFixedRate(
            () -> System.out.println("another thing"),
            xSeconds,
            2 * xSeconds,
            TimeUnit.SECONDS
        );

        // 若需停止任务，调用 executor.shutdown(); 即可
    }
}

注意：

• 不需要任务时务必调用executor.shutdown()关闭线程池，避免资源泄漏。
• 该方案比手动sleep更稳定，尤其适合复杂并发场景。

内容的提问来源于stack exchange，提问作者ralkin