Java案例怎么实现线程休眠？

本文目录导读：

1. 使用 Thread.sleep() 方法（最常用）
2. 在多线程中使用线程休眠
3. 使用 TimeUnit 类（推荐方式）
4. 处理休眠中断的完整示例
5. 实际应用场景：定时任务模拟
6. 重要注意事项：

在Java中实现线程休眠主要有以下几种方式,我这里为你提供详细的案例和代码示例。

使用 Thread.sleep() 方法（最常用）

这是最基础也是最常用的线程休眠方式。

基本用法示例：

public class ThreadSleepExample {
    public static void main(String[] args) {
        System.out.println("程序开始");
        try {
            // 让当前线程休眠3秒
            System.out.println("线程将休眠3秒...");
            Thread.sleep(3000);  // 参数单位为毫秒
            System.out.println("线程休眠结束");
        } catch (InterruptedException e) {
            System.out.println("线程被中断");
            e.printStackTrace();
        }
        System.out.println("程序结束");
    }
}

实现倒计时功能：

public class CountdownExample {
    public static void main(String[] args) {
        System.out.println("倒计时开始：");
        for (int i = 5; i > 0; i--) {
            System.out.println(i);
            try {
                Thread.sleep(1000);  // 每秒打印一次
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("倒计时结束！");
    }
}

在多线程中使用线程休眠

public class MultiThreadSleepExample {
    public static void main(String[] args) {
        // 创建并启动多个线程
        for (int i = 1; i <= 3; i++) {
            Thread worker = new WorkerThread("线程-" + i);
            worker.start();
        }
    }
}
class WorkerThread extends Thread {
    private String threadName;
    public WorkerThread(String name) {
        this.threadName = name;
    }
    @Override
    public void run() {
        System.out.println(threadName + " 开始执行");
        for (int i = 1; i <= 3; i++) {
            System.out.println(threadName + " - 第" + i + "次执行");
            try {
                // 每个线程休眠不同的时间模拟不同处理时间
                Thread.sleep((long)(Math.random() * 2000));
            } catch (InterruptedException e) {
                System.out.println(threadName + " 被中断");
            }
        }
        System.out.println(threadName + " 执行完毕");
    }
}

使用 TimeUnit 类（推荐方式）

java.util.concurrent.TimeUnit 提供了更优雅的时间表示方式：

import java.util.concurrent.TimeUnit;
public class TimeUnitSleepExample {
    public static void main(String[] args) {
        System.out.println("使用TimeUnit进行线程休眠");
        try {
            // 休眠5秒
            System.out.println("休眠5秒...");
            TimeUnit.SECONDS.sleep(5);
            // 休眠500毫秒
            System.out.println("休眠500毫秒...");
            TimeUnit.MILLISECONDS.sleep(500);
            // 休眠1分钟
            System.out.println("休眠1分钟...");
            TimeUnit.MINUTES.sleep(1);
        } catch (InterruptedException e) {
            System.out.println("线程休眠被中断");
            e.printStackTrace();
        }
    }
}

处理休眠中断的完整示例

public class InterruptedSleepExample {
    public static void main(String[] args) {
        Thread sleepingThread = new Thread(() -> {
            System.out.println("线程开始执行");
            try {
                System.out.println("线程将休眠10秒...");
                Thread.sleep(10000);
                System.out.println("线程自然唤醒");
            } catch (InterruptedException e) {
                System.out.println("线程在休眠中被中断！");
                // 通常需要恢复中断状态或退出
                Thread.currentThread().interrupt();
                return;
            }
            System.out.println("线程继续执行其他任务");
        });
        sleepingThread.start();
        // 主线程等待3秒后中断休眠线程
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("主线程准备中断休眠线程");
        sleepingThread.interrupt();
    }
}

实际应用场景：定时任务模拟

import java.text.SimpleDateFormat;
import java.util.Date;
public class ScheduledTaskExample {
    public static void main(String[] args) {
        // 模拟每5秒执行一次的任务
        System.out.println("定时任务开始，每5秒执行一次");
        for (int i = 0; i < 5; i++) {
            executeTask();
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                System.out.println("定时任务被中断");
                break;
            }
        }
        System.out.println("定时任务结束");
    }
    private static void executeTask() {
        SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
        String currentTime = sdf.format(new Date());
        System.out.println("[" + currentTime + "] 执行任务...");
        // 模拟任务执行时间
        try {
            Thread.sleep(1000);  // 任务执行需要1秒
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        System.out.println("[" + currentTime + "] 任务完成");
    }
}

重要注意事项：

1. InterruptedException处理：Thread.sleep() 会抛出 InterruptedException，必须处理这个异常,不要直接忽略。

2. 精度限制：sleep() 的精度依赖于操作系统,不能保证精确的定时。

3. 不释放锁：Thread.sleep() 不会释放已持有的锁资源。

4. 推荐使用 TimeUnit：在Java 5+ 推荐使用 TimeUnit.SECONDS.sleep() 等方式,代码更清晰。

5. 不要使用 sleep 做同步：不要用 sleep() 来实现线程同步，应该使用 wait/notify 或 Lock/Condition。

这些就是Java中实现线程休眠的主要方式和案例,你可以根据具体需求选择合适的方法。