Java中的wait()和notify()

一、基本概念

在Java中，任何一个Object对象都有两个重要的方法：wait()和notify()。这两个方法被用来实现线程控制和线程之间的通信。wait()方法使当前的线程等待，直到另一个线程调用该对象的notify()方法或notifyAll()方法，从而唤醒该线程；而notify()方法则是唤醒在该对象上等待的线程之一，当有多个线程等待该对象时，notify()方法只会唤醒其中的一个线程。

这里需要注意的是，wait()和notify()方法必须在一个synchronized块或者synchronized方法中调用，否则会抛出IllegalMonitorStateException异常。

二、wait()的使用

wait()方法用于使当前线程进入等待状态，并且释放该对象的锁。

public synchronized void add(Object obj) {
    while (isFull()) {
        try {
            wait();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    // add the object to the buffer
    notifyAll();
}

如上面的代码所示，如果队列已满，那么线程就会进入等待状态。在等待过程中，线程会释放该对象的锁，其他线程可以获取该锁并操作该队列。当其他线程向队列中添加元素时，会调用notifyAll()方法来唤醒处于等待状态的线程。

需要注意的是，调用wait()方法后，线程会一直处于等待状态，直到有其他线程调用notify()或notifyAll()方法才会被唤醒。如果没有其他线程调用相应的方法，那么该线程就会一直处于等待状态，这将导致死锁。

三、notify()的使用

notify()方法用于唤醒在该对象上等待的线程之一，并且不会释放该对象的锁。

public synchronized Object remove() {
    while (isEmpty()) {
        try {
            wait();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    // remove an object from the buffer
    notifyAll();
    return obj;
}

如上面的代码所示，如果队列为空，线程就会进入等待状态，直到有其他线程向队列中添加元素时，会调用notifyAll()方法来唤醒处于等待状态的线程。

需要注意的是，调用notify()方法后，只会唤醒等待队列中的一个线程，而不是唤醒所有的线程。如果有多个线程等待该对象，那么唤醒哪个线程是不确定的。

四、wait()和notify()的注意点

1、wait()和notify()必须在synchronized块或者synchronized方法中调用。

2、wait()方法会使当前线程进入等待状态，并且释放该对象的锁；notify()方法会唤醒在该对象上等待的线程之一，并且不会释放该对象的锁。

3、调用wait()方法后，线程会一直处于等待状态，直到有其他线程调用相应的方法才会被唤醒；调用notify()方法后，只会唤醒等待队列中的一个线程，而不是唤醒所有的线程。

4、为了避免死锁，需要在程序中使用notifyAll()方法来唤醒处于等待状态的所有线程。

五、代码示例

public class Buffer {
    private Object[] buffer;
    private int start = 0;
    private int end = 0;
    private int count = 0;

    public Buffer(int size) {
        buffer = new Object[size];
    }

    public synchronized void add(Object obj) {
        while (isFull()) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        buffer[end] = obj;
        end = (end + 1) % buffer.length;
        count++;
        notifyAll();
    }

    public synchronized Object remove() {
        while (isEmpty()) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        Object obj = buffer[start];
        start = (start + 1) % buffer.length;
        count--;
        notifyAll();
        return obj;
    }

    private boolean isEmpty() {
        return count == 0;
    }

    private boolean isFull() {
        return count == buffer.length;
    }
}

上面的代码演示了一个生产者-消费者模型，使用wait()和notify()方法实现了线程之间的通信。

在该模型中，Buffer是一个循环队列，当队列已满时，生产者线程会调用wait()方法进入等待状态，直到有其他线程调用notify()或notifyAll()方法来唤醒它。当队列为空时，消费者线程会调用wait()方法进入等待状态，直到有其他线程调用notify()或notifyAll()方法来唤醒它。