Java线程阻塞方法sleep()与wait()的全面讲解

简介

在Java多线程编程中，线程状态的控制是非常重要的一个部分。线程可以处于多种状态，例如就绪状态，运行状态，阻塞状态等等。本篇文章主要讲解Java线程阻塞方法sleep()与wait()的使用和区别。

sleep()方法

sleep()方法是Thread类中一个静态方法。sleep()方法的作用是使当前线程暂停执行一段时间，然后再继续执行。sleep()方法接受一个参数，表示休眠的时间的毫秒数。这个参数可以是long类型的，也可以是int类型的。

try {
    Thread.sleep(1000); // 暂停1秒
} catch (InterruptedException e) {
    e.printStackTrace();
}

在上面的示例中，当线程执行到sleep()方法时，这个线程就会进入睡眠状态，并且暂停执行1秒钟。在1秒钟之后，这个线程会醒来，继续往下执行。

需要注意的是，在调用sleep()方法时，需要处理InterruptedException异常。如果在休眠过程中，调用Thread.interrupt()方法中断了这个线程，那么sleep()方法就会抛出这个异常。

wait()方法

wait()方法是Object类中的一个方法。wait()方法的作用是使当前线程进入等待状态，等待其他线程通过notify()或notifyAll()方法唤醒它。wait()方法可以接受一个参数，表示等待的时间的毫秒数，也可以不传参数。

synchronized (lock) {
    try {
        lock.wait(); // 等待其他线程唤醒
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

在上面的示例中，synchronized锁住了一个对象lock，然后在这个对象上调用了wait()方法。这个线程就会进入等待状态，并且释放锁。等待其他线程调用lock.notify()方法唤醒它。

需要注意的是，在调用wait()方法时，需要先获取synchronized锁，即wait()方法必须在synchronized块中调用，否则会抛出IllegalMonitorStateException异常。

区别

• wait()方法必须在synchronized块中调用，而sleep()方法不需要。
• wait()方法会释放锁，而sleep()方法不会释放锁。
• wait()方法只有在被其他线程调用notify()或notifyAll()方法时才会继续执行，而sleep()方法会在规定的时间后自动醒来继续执行。

示例

示例一：使用sleep()方法

public class SleepDemo {

    public static void main(String[] args) {
        Runnable task = () -> {
            for (int i = 0; i < 10; i++) {
                System.out.println("线程" + Thread.currentThread().getName() + "执行第" + i + "次任务");
                try {
                    Thread.sleep(1000); // 暂停1秒钟
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };

        new Thread(task, "A").start();
        new Thread(task, "B").start();
    }
}

在上面的示例中，创建了两个线程并行执行，每个线程都会执行10次任务，每次任务之间暂停1秒钟。虽然两个线程中的任务不是完全同步的，但是它们是交替执行的。

示例二：使用wait()方法

public class WaitDemo {
    private static final Object lock = new Object();

    public static void main(String[] args) {
        Runnable task1 = () -> {
            synchronized (lock) {
                System.out.println(Thread.currentThread().getName() + "开始执行");
                try {
                    lock.wait(); // 等待唤醒，释放锁
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "继续执行");
            }
        };

        Runnable task2 = () -> {
            synchronized (lock) {
                System.out.println(Thread.currentThread().getName() + "开始执行");
                lock.notify(); // 唤醒等待线程
                System.out.println(Thread.currentThread().getName() + "唤醒线程");
            }
        };

        new Thread(task1, "A").start();
        new Thread(task2, "B").start();
    }
}

在上面的示例中，创建了两个线程并行执行，线程A会先获得锁并进入等待状态，线程B会在执行过程中唤醒线程A。唤醒线程A会释放锁，线程B会获得锁并继续执行。