Java中的wait()和notify()方法詳解

wait() 和 notify() 是 Java 的 Object 类中的两个方法，它们被用于多线程间的协作。具体来说，这两个方法被设计用来在并发编程中处理线程间的通信问题，允许线程等待某个条件成立或通知其他线程某个条件已经满足。

1. wait() 方法

• wait() 方法使得当前线程（调用 wait() 的线程）进入等待状态，直到其他线程调用同一个对象的 notify() 或 notifyAll() 方法。
• 当前线程必须拥有该对象的监视器（即对象锁）才能调用其 wait() 方法。换句话说，必须在同步块或同步方法中调用 wait()。
• 调用 wait() 后，线程会释放它持有的对象锁，进入等待池。
• 线程可以被唤醒的情况包括：
  • 其他线程调用了同一个对象的 notify() 或 notifyAll() 方法。
  • 其他线程中断了该线程。
  • 其他线程对该线程调用了不带超时的 Thread.join() 方法。
  • 某些特定情况可能导致“虚假唤醒”，即使没有上述任何操作，线程也可能被唤醒。

2. notify() 方法

• notify() 方法用于唤醒一个正在等待该对象监视器的线程。如果多个线程在等待，具体唤醒哪一个是不确定的。
• 和 wait() 一样，notify() 也必须在同步块或同步方法中被调用，因为调用 notify() 需要持有对象的监视器。
• 当 notify() 被调用时，等待池中的某个线程将被移动到锁池中，等待获取对象锁。一旦获取了锁，线程就可以继续执行了。

示例

这里有一个简单的示例，演示了如何使用 wait() 和 notify() 实现一个简单的线程间通信：

public class WaitNotifyExample {
    private boolean flag = false;

    public synchronized void producer() {
        while (flag) {
            try {
                wait(); // 如果 flag 为 true，则等待
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        System.out.println("生产者开始生产...");
        // 这里模拟生产的过程
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("生产者生产完毕，通知消费者消费...");
        flag = true;
        notify(); // 生产完毕，通知消费者
    }

    public synchronized void consumer() {
        while (!flag) {
            try {
                wait(); // 如果 flag 为 false，则等待
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        System.out.println("消费者开始消费...");
        // 这里模拟消费的过程
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("消费者消费完毕，通知生产者生产...");
        flag = false;
        notify(); // 消费完毕，通知生产者
    }

    public static void main(String[] args) {
        WaitNotifyExample example = new WaitNotifyExample();

        // 创建生产者和消费者线程
        Thread producerThread = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                example.producer();
            }
        });

        Thread consumerThread = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                example.consumer();
            }
        });

        // 启动线程
        producerThread.start();
        consumerThread.start();
    }
}

注意：这个示例存在一个问题，即可能会出现“活锁”现象，因为生产者和消费者都可能在对方还未处理完时就不断调用 notify()，导致对方刚被唤醒就又进入等待状态。为了避免这种情况，可以使用条件变量（如 java.util.concurrent.locks.Condition）或者更高级的同步工具（如 Semaphore、CountDownLatch 等）。不过，为了简单起见，这里我们只演示了 wait() 和 notify() 的基本用法。

另外，还需要注意，wait()、notify() 和 notifyAll() 方法都是 final 方法，不能被子类覆盖。这些方法都与线程的通信和协作有关，因此在设计和实现并发程序时需要谨慎使用。

上面的示例代码存在一些问题，它并不能正确地实现生产者和消费者之间的交替执行。这是因为当 flag 变量的状态改变后，没有机制确保之前被唤醒的线程能够再次进入等待状态，直到对方完成其任务。这通常会导致两个线程都在不停地唤醒对方，但实际上并没有完成任何有用的工作，这就是所谓的“活锁”。

为了修复这个问题，我们可以使用 while 循环来检查条件，而不是 if 语句（尽管示例中已经使用了 while 循环，但逻辑仍然不正确）。然而，更好的做法是使用 Java 并发包 java.util.concurrent 中的工具类，如 BlockingQueue，这些类为生产者-消费者问题提供了更高级的解决方案。

不过，为了继续解释 wait() 和 notify() 的正确用法，并修复上面的示例，我们可以稍微调整代码逻辑：

public class WaitNotifyExample {
    private boolean flag = false;

    public synchronized void producer() {
        while (flag) {
            try {
                wait(); // 如果 flag 为 true，生产者等待
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt(); // 重新设置中断状态
                throw new RuntimeException(e);
            }
        }

        // 生产产品的代码
        System.out.println("生产者生产了一个产品。");

        flag = true; // 设置 flag 表示产品已经生产
        notifyAll(); // 通知所有等待的线程，可能有多个消费者或其他生产者
    }

    public synchronized void consumer() {
        while (!flag) {
            try {
                wait(); // 如果 flag 为 false，消费者等待
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt(); // 重新设置中断状态
                throw new RuntimeException(e);
            }
        }

        // 消费产品的代码
        System.out.println("消费者消费了一个产品。");

        flag = false; // 设置 flag 表示产品已经被消费
        notifyAll(); // 通知所有等待的线程，可能有多个生产者或其他消费者
    }

    public static void main(String[] args) {
        WaitNotifyExample warehouse = new WaitNotifyExample();

        Thread producer = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                warehouse.producer();
            }
        });

        Thread consumer = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                warehouse.consumer();
            }
        });

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

然而，这个代码仍然不是最佳实践，因为它只允许一个生产者和一个消费者交替执行，而且它假设生产者和消费者的执行速度大致相同。在实际情况中，我们可能需要处理多个生产者和消费者，并且他们的速度可能会有所不同。

更好的做法是使用条件变量或信号量来控制访问共享资源。在 Java 中，java.util.concurrent.locks 包提供了 Lock 和 Condition 接口，可以实现更细粒度的锁和条件等待。

此外，对于生产者-消费者问题，java.util.concurrent 包中的 BlockingQueue 是一个非常好的选择，因为它内部实现了所有的同步和等待逻辑，你只需要将对象放入队列或从队列中取出对象即可。

总的来说，虽然 wait() 和 notify() 是 Java 中基本的线程通信机制，但在实际开发中，我们通常会使用更高级的并发工具来简化代码和提高可靠性。