Java线程休眠的5种方法

Java中的线程可以通过休眠来暂停一段时间。线程的休眠有5种方法，本文将详细介绍这5种方法，并给出代码示例。

方法一：使用Thread.sleep()

Thread.sleep()是Java中比较常用的线程休眠方法。它可以将当前正在执行的线程休眠指定的时间，单位是毫秒。下面是使用Thread.sleep()方法的示例：

public class SleepExample {
    public static void main(String[] args) {
        System.out.println("开始");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("结束");
    }
}

在这个例子中，main()方法将休眠2秒钟，然后输出“结束”。注意，Thread.sleep()方法可能会抛出InterruptedException异常，因此我们应该在try-catch块中使用它。

方法二：使用Object.wait()

Object.wait()方法可以使当前线程等待另一个线程发出通知。它将当前线程置于“等待状态”，直到另一个线程调用了该对象的notify()或notifyAll()方法。下面是一个使用Object.wait()方法的示例：

public class WaitExample {
    public static void main(String[] args) {
        final Object lock = new Object();
        Thread t1 = new Thread(() -> {
            synchronized (lock) {
                try {
                    System.out.println("线程1开始等待");
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("线程1结束等待");
            }
        });
        Thread t2 = new Thread(() -> {
            synchronized (lock) {
                System.out.println("线程2开始唤醒");
                lock.notify();
                System.out.println("线程2结束唤醒");
            }
        });
        t1.start();
        t2.start();
    }
}

在这个例子中，线程1将进入等待状态，直到线程2调用了lock.notify()方法。

方法三：使用Thread.yield()

Thread.yield()方法会提示线程调度器让出一次CPU资源。它会将CPU时间片让给其他线程，从而使所有线程都有机会获得CPU资源。下面是Thread.yield()方法的示例：

public class YieldExample {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                System.out.println("线程1第" + (i + 1) + "次执行");
                Thread.yield();
            }
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                System.out.println("线程2第" + (i + 1) + "次执行");
                Thread.yield();
            }
        });
        t1.start();
        t2.start();
    }
}

在这个例子中，线程1和线程2将交替执行，每次执行前都会调用Thread.yield()方法。

方法四：使用LockSupport.park()

LockSupport.park()是一个比较底层的方法，可以使当前线程等待另一个线程发出通知。它可以被阻塞和解除阻塞，没有等待上限的限制。下面是LockSupport.park()方法的示例：

public class ParkExample {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            System.out.println("线程1开始等待");
            LockSupport.park();
            System.out.println("线程1结束等待");
        });
        Thread t2 = new Thread(() -> {
            System.out.println("线程2开始唤醒");
            LockSupport.unpark(t1);
            System.out.println("线程2结束唤醒");
        });
        t1.start();
        t2.start();
    }
}

在这个例子中，线程1将进入等待状态，直到线程2调用了LockSupport.unpark(t1)方法。

方法五：使用ScheduledExecutorService.schedule()

ScheduledExecutorService.schedule()方法可以在指定的时间之后执行一次任务或周期性地执行任务。下面是ScheduledExecutorService.schedule()方法的示例：

public class ScheduleExample {
    public static void main(String[] args) {
        ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
        Runnable task = () -> System.out.println("执行任务");
        executor.schedule(task, 5, TimeUnit.SECONDS);
        executor.shutdown();
    }
}

在这个例子中，程序将在5秒钟后执行一次任务。注意，我们需要在程序退出前关闭ScheduledExecutorService。

总结

这篇文章介绍了Java中线程休眠的5种方法，其中包括：Thread.sleep()、Object.wait()、Thread.yield()、LockSupport.park()和ScheduledExecutorService.schedule()。在实际开发中，我们应该根据具体情况选择合适的方法。