线程中的wait和notify方法

1. 多线程中wait和notify方法

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

/article/11235364.html

/article/11235363.html

这两个方法是一对死冤家，有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的方法？这个是因为一个线程可能会有多个锁，因为如果通过线程来控制等待锁，情况会变得很复杂的。