线程中的wait和notify方法

1. 多线程中wait和notify方法

请先阅读下我的博客中关于线程的状态的两篇文章后，再来阅读这篇文章，药物配合吃，疗效更加【坏笑】。

http://blog.csdn.net/duxingxia_007/article/details/49310275
http://blog.csdn.net/duxingxia_007/article/details/47009445

这两个方法是一对死冤家，有wait()的地方，需要经过notify才能触发再次进入队列；注意这是指wait()方法，不是wait(long time)方法。wait和notify在什么场景下会使用到，以及他们之间的关系是什么样子的？下面就来一一解答。

1.1 示例

现在模拟这样子的一个场景，生产者用来生产资源，消费者会来消费资源
（1）消费者发现资源不足，小于给定的阈值时，会通知生产者生产资源，此时消费者进入等待队列；
（2）当资源充足时，生产者会通知正在等待消费的消费者来消费资源，生产者会停止生产资源。
下面我们的示例中这个指定的阈值设置为0。

/**
 * 资源类
 */
public class Resource {
    /**
     * 总数量
     */
    private int amount;

    public int getAmount() {
        return amount;
    }

    public void setAmount(int amount) {
        this.amount = amount;
    }

}

/**
 * 生产者
 */
public class Producer implements Runnable {
    private Resource resource;

    public Producer(Resource resource) {
        this.setResource(resource);
    }

    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {

            synchronized (resource) {
                if( resource.getAmount() <=0 ){
                    resource.setAmount(resource.getAmount() + 1);
                    System.out.println("producer amount=" + resource.getAmount());
                }else{
                    try {
                        this.wait();
                        System.out.println("生产者进入等待状态，等待消费者消费资源,amount="+resource.getAmount());
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }   
                }

            }
        }

    }

    public Resource getResource() {
        return resource;
    }

    public void setResource(Resource resource) {
        this.resource = resource;
    }
}

/**
 * 消费者
 */
public class Consumer implements Runnable {

    private Resource resource;

    public Consumer(Resource resource) {
        this.setResource(resource);
    }

    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            synchronized (resource) {

                if (resource.getAmount() <= 0) {
                    // 没有资源时通知生产者生产资源，此时消费者进入等待队列进行等待
                    System.out.println("消费者通知所有的产生者，资源已经为0了，请生产资源");
                    this.notify();
                } else {
                    resource.setAmount(resource.getAmount() - 1);
                    System.out.println("consumer amount="
                            + resource.getAmount());
                }

            }

        }

    }

    public Resource getResource() {
        return resource;
    }

    public void setResource(Resource resource) {
        this.resource = resource;
    }

}

public class Main {

    public static void main(String[] args){

        Resource resource = new Resource();
        resource.setAmount(2);

        Consumer consumer = new Consumer(resource);
        consumer.run();
        Producer producer = new Producer(resource);
        producer.run();
    }

}

你知道当运行上面的main方法后，输出的结果是什么呢？见下面的结果：

consumer amount=1Exception in thread “main”
consumer amount=0
消费者通知所有的产生者，资源已经为0了，请生产资源
java.lang.IllegalMonitorStateException
at java.lang.Object.notify(Native Method)
at Consumer.run(Consumer.java:17)
at Main.main(Main.java:12)

你知道这是什么原因呢？为什么会出现这种错误呢？在这里我是故意弄出错误来，目的是要加强对wait和notify的理解，所以不要着急，慢慢来看。
我们从上面的报错信息java.lang.IllegalMonitorStateException来分析下，分析的方法是先来了解下notify和wait方法的实际含义。

void notify() 该方法只能在同步块和同步方法块内使用，目的在于随机选择一个在该对象上调用了wait方法的线程，解除该线程的阻塞状态；如果当前线程不是锁的持有者，则会抛出一个java.lang.IllegalMonitorStateException异常。

void wait() 该方法只能在同步块和同步方法块中使用，目的在于使得当前线程进入阻塞状态，直到有notify()方法或者notifyAll()方法通知；如果当前线程不是锁的持有者，该方法抛出一个IllegalMonitorStateException异常。

这里需要搞明白两点（1）这里锁是指的谁？（2）当前线程指的是哪个线程？是main方法所在的主线程还是producer线程还是consumer线程？
首先这里的锁指的是对象锁，这个对象是resource这个公用的资源，被生产者和消费者共同使用。
一个线程被唤醒不代表立即获取了对象的monitor，只有等调用完notify()或者notifyAll()并退出synchronized块，释放对象锁后，其余线程才可获得锁执行。

修改后代码为

/**
 * 消费者
 */
public class Consumer implements Runnable {

    private Resource resource;

    public Consumer(Resource resource) {
        this.setResource(resource);
    }

    @Override
    public void run() {
        for(int i =0;i<10;i++){
            synchronized (resource) {
                if (resource.getAmount() <= 0) {
                    // 没有资源时通知生产者生产资源，此时消费者进入等待队列进行等待
                    System.out.println("消费者通知所有的产生者，资源已经为0了，请生产资源");
                    resource.notify();
                    System.out.println("消费者发出了notify，此时资源amount="+resource.getAmount());
                    try {
                        System.out.println("消费者进入wait等待状态");
                        resource.wait();
                        System.out.println("消费者结束wait等待状态");
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }else{
                    resource.setAmount(resource.getAmount() - 1);
                    System.out.println("消费者消费了资源，剩余资源 amount="
                                + resource.getAmount());
                }
            }
            System.out.println("消费者synchronize方法结束，释放resource锁");
        }
    }

    public Resource getResource() {
        return resource;
    }

    public void setResource(Resource resource) {
        this.resource = resource;
    }

}

/**
 * 生产者
 */
public class Producer implements Runnable {
    private Resource resource;

    public Producer(Resource resource) {
        this.setResource(resource);
    }

    @Override
    public void run() {
        for(int i =0;i<10;i++){
            synchronized (resource) {
                if( resource.getAmount() <=0 ){
                    resource.setAmount(resource.getAmount() + 1);
                    System.out.println("生产者生产资源，开始notify，生产后数量为amount=" + resource.getAmount());
                    resource.notify();
                    System.out.println("生产者发出了notify，此时资源amount="+resource.getAmount());
                }else{
                    try {
                        System.out.println("生产者进入wait等待消费者消费资源");
                        resource.wait();
                        System.out.println("生产者结束wait等待消费者消费资源结束");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
            System.out.println("生产者结束synchronized方法，释放resource锁");
        }
    }

    public Resource getResource() {
        return resource;
    }

    public void setResource(Resource resource) {
        this.resource = resource;
    }
}

执行后的结果为

消费者通知所有的产生者，资源已经为0了，请生产资源
消费者发出了notify，此时资源amount=0
消费者进入wait等待状态
生产者生产资源，开始notify，生产后数量为amount=1
生产者发出了notify，此时资源amount=1
生产者结束synchronized方法，释放resource锁
消费者结束wait等待状态
消费者synchronize方法结束，释放resource锁
生产者进入wait等待消费者消费资源
消费者消费了资源，剩余资源 amount=0
消费者synchronize方法结束，释放resource锁
消费者通知所有的产生者，资源已经为0了，请生产资源
消费者发出了notify，此时资源amount=0
消费者进入wait等待状态
生产者结束wait等待消费者消费资源结束
生产者结束synchronized方法，释放resource锁
生产者生产资源，开始notify，生产后数量为amount=1
生产者发出了notify，此时资源amount=1
生产者结束synchronized方法，释放resource锁
消费者结束wait等待状态
消费者synchronize方法结束，释放resource锁
生产者进入wait等待消费者消费资源
消费者消费了资源，剩余资源 amount=0
消费者synchronize方法结束，释放resource锁
消费者通知所有的产生者，资源已经为0了，请生产资源
消费者发出了notify，此时资源amount=0
消费者进入wait等待状态
生产者结束wait等待消费者消费资源结束
生产者结束synchronized方法，释放resource锁
生产者生产资源，开始notify，生产后数量为amount=1
生产者发出了notify，此时资源amount=1
生产者结束synchronized方法，释放resource锁
消费者结束wait等待状态
消费者synchronize方法结束，释放resource锁
消费者消费了资源，剩余资源 amount=0
消费者synchronize方法结束，释放resource锁
消费者通知所有的产生者，资源已经为0了，请生产资源
消费者发出了notify，此时资源amount=0
消费者进入wait等待状态

从结果中可以判断出，当进入wait时，当前线程被阻塞，而notify并不会阻塞线程的方法。wait方法会等到notify之后才会执行；此外，当消费者线程进入“消费者进入wait等待状态”等待“消费者结束wait等待状态”这段时间片内，生产者生产资源，并notify，此时消费者线程要回到执行打扫“消费者结束wait等待状态”需要等待生产者线程释放掉锁，即生产者要执行完synchronized方法后才算释放掉锁。

最后语

为什么这个notify和wait方法不是加在线程上的，即线程内部的方法，而是每个Object的方法？这个是因为一个线程可能会有多个锁，因为如果通过线程来控制等待锁，情况会变得很复杂的。