JAVA线程sleep()和wait()详解及实例

简介

Java中的线程是轻量级的，同时也是一种几乎可以同时执行多个任务的机制。线程具有并发执行的能力，可以实现复杂的并发操作。线程的任何操作都需要以某种方式调度，由操作系统或JVM负责分配资源，因此线程通常比进程更高效。本文将重点介绍Java线程中的sleep()和wait()方法。

sleep()方法

sleep()方法使当前线程休眠一段时间，时间由程序员指定。调用sleep()方法的线程不会与其他线程交替执行，而是进入阻塞状态。

语法：public static void sleep(long millis) throws InterruptedException

例如，在下面的示例中，将启动两个线程分别打印“Hello”和“World”并休眠一段时间：

public class SleepExample {
    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                System.out.println("Hello");
                try {
                    Thread.sleep(1000); // 休眠1秒
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                System.out.println("World");
                try {
                    Thread.sleep(1000); // 休眠1秒
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        thread1.start();
        thread2.start();
    }
}

输出结果：

Hello
World
Hello
World
Hello
World
Hello
World
Hello
World

wait()方法

wait()方法是Object类的方法，它会使当前线程等待，直到其他线程调用notify()或notifyAll()方法唤醒它。因此，wait()方法通常与synchronized关键字一起使用。线程必须拥有对象的锁，才能调用这个对象的wait()方法。

语法：public final void wait() throws InterruptedException

例如，在下面的示例中，创建了一个生产者线程和一个消费者线程，并使用wait()和notify()方法使它们交替地执行：

public class WaitExample {
    public static void main(String[] args) {
        final Object lock = new Object();
        List<Integer> buffer = new ArrayList<>();

        Thread producer = new Thread(() -> {
            int i = 1;
            while (true) {
                synchronized (lock) {
                    if (buffer.size() == 1) {
                        try {
                            lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    buffer.add(i);
                    System.out.println("Producer produced - " + i++);
                    lock.notify();
                }
                try {
                    Thread.sleep(1000); // 休眠1秒
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        Thread consumer = new Thread(() -> {
            while (true) {
                synchronized (lock) {
                    if (buffer.size() == 0) {
                        try {
                            lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    int removed = buffer.remove(0);
                    System.out.println("Consumer consumed - " + removed);
                    lock.notify();
                }
                try {
                    Thread.sleep(1000); // 休眠1秒
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        producer.start();
        consumer.start();
    }
}

输出结果：

Producer produced - 1
Consumer consumed - 1
Producer produced - 2
Consumer consumed - 2
Producer produced - 3
Consumer consumed - 3
...

总结

本文介绍了Java线程中的sleep()和wait()方法的详细信息以及使用示例。sleep()方法可以使当前线程休眠一段时间，并且不释放锁。wait()方法在等待其他线程调用notify()或notifyAll()时会释放锁，并挂起当前线程。在使用wait()方法时，必须拥有对象的锁。