java基本教程之java线程等待与java唤醒线程 java多线程教程

Java线程等待与唤醒线程

线程等待

线程等待就是让线程先暂停一下，等待特定的条件被满足时再继续执行，一般情况下会使用wait()方法进行线程等待。

wait()方法的用法：

synchronized(monitorObject) {
    while(!conditionWarranted()) {
        monitorObject.wait();
}

代码中的monitorObject表示该操作的监视器，一般是某个对象；而conditionWarranted()则是等待条件的方法，返回true表示条件被满足，返回false则表示线程需要继续等待。使用wait()方法时需要注意以下三点：

1. wait()方法只能在同步代码块或同步方法中使用。
2. 在等待之前，应该先判断等待的条件是否已经满足，如示例代码中的while(!conditionWarranted())。
3. 线程在等待时会释放锁，等待醒来后需要重新获取锁再继续执行。

唤醒线程

当等待条件被满足时，可以使用notify()或notifyAll()方法唤醒等待的线程。

notify()方法会随机唤醒一个等待的线程，而notifyAll()会唤醒所有等待的线程。需要注意以下几点：

1. notify()或notifyAll()方法同样只能在同步代码块或同步方法中使用，并且需要获取到与wait()方法中使用的同一把锁。
2. 唤醒线程需要等待当前线程释放锁后才能执行。

示例说明1

public class ThreadDemo {
    public static void main(String[] args) {
        final Object monitorObject = new Object();
        Thread threadA = new Thread(() -> {
            synchronized(monitorObject) {
                try {
                    System.out.println("Thread A is waiting.");
                    monitorObject.wait();
                    System.out.println("Thread A is awakened.");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        Thread threadB = new Thread(() -> {
            synchronized(monitorObject) {
                System.out.println("Thread B is running.");
                monitorObject.notify();
                System.out.println("Thread B notified.");
            }
        });
        threadA.start();
        threadB.start();
    }
}

上面示例代码中，创建了两个线程threadA和threadB。threadA负责等待monitorObject对象的唤醒，threadB则会在执行过程中唤醒等待的线程。

输出结果为：

Thread A is waiting.
Thread B is running.
Thread B notified.
Thread A is awakened.

示例说明2

public class ThreadDemo {
    public static void main(String[] args) {
        final Object monitorObject = new Object();
        Thread threadA = new Thread(() -> {
            synchronized(monitorObject) {
                try {
                    System.out.println("Thread A is waiting.");
                    monitorObject.wait();
                    System.out.println("Thread A is awakened.");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        Thread threadB = new Thread(() -> {
            synchronized(monitorObject) {
                System.out.println("Thread B is running.");
                monitorObject.notifyAll();
                System.out.println("Thread B notified all.");
            }
        });
        Thread threadC = new Thread(() -> {
            synchronized(monitorObject) {
                try {
                    System.out.println("Thread C is waiting.");
                    monitorObject.wait();
                    System.out.println("Thread C is awakened.");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        threadA.start();
        threadB.start();
        threadC.start();
    }
}

上面示例代码中，同样是创建了三个线程，threadA和threadC等待monitorObject对象唤醒，threadB唤醒所有等待的线程。

输出结果为：

Thread A is waiting.
Thread B is running.
Thread C is waiting.
Thread B notified all.
Thread C is awakened.
Thread A is awakened.

从输出结果可以看出，threadB成功唤醒了所有等待monitorObject对象的线程。