利用wait()和notify()实现生产者与消费者问题

生产者与消费者问题是并发编程里面的经典问题，下面用wait()和notify()来实现消费者线程和生产者线程的并发执行。

说之前先讲几个概念：

wait()与sleep()的区别：

1.首先sleep()是Thread()类的方法，而wait()是Object类的方法，包括notify()，notifyAll()都是Object类的方法

2.sleep()方法是休眠，阻塞线程的同时仍然会持有锁，也就是说它休眠期间其他线程仍然无法获得锁，同时sleep()休眠时自动醒 的；而调用wait()方法时，则自动释放锁，也就是其他线程可以获得锁，而且wait()是无法自动醒的，只有通过notify()或 notifyAll() 才行。

notify()与notifyAll()的区别

notify()一次只能激活一个对这个对象进行wait()的线程，当多个线程都对此对象wait()时，是随机挑一个notify()，而notifyAll()是一次 性激活所以对此对象进行wait()的线程。

接下来说说利用wait()和notify()来实现生产者和消费者并发问题：

显然要保证生产者和消费者并发运行不出乱，主要要解决：当生产者线程的缓存区为满的时候，就应该调用wait()来停止生产者继续生产，而当生产者满的缓冲区被消费者消费掉一块时，则应该调用notify()唤醒生产者，通知他可以继续生产；同样，对于消费者，当消费者线程的缓存区为空的时候，就应该调用wait()停掉消费者线程继续消费，而当生产者又生产了一个时就应该调用notify()来唤醒消费者线程通知他可以继续消费了。

当然我们必须在wait()和notify()的时候锁住我们所要操作的对象,这里即缓存区，下面是一个使用wait()的notify()的规范代码模板：

synchronized (sharedObject) { //锁住操作对象
while (condition) { //当某个条件下
sharedObject.wait(); //进入wait

}
// 做了什么事，就可以激活
shareObject.notify();
}

下面就贴一下wait和notify实现一个生产者线程和一个消费者线程并发执行的代码：

import java.util.LinkedList;
import java.util.Queue;
import java.util.Random;

public class ProducerConsumerInJava {
public static void main(String args[]) {
System.out.println("How to use wait and notify method in Java");
System.out.println("Solving Producer Consumper Problem");
Queue<Integer> buffer = new LinkedList<>();
int maxSize = 10;
Thread producer = new Producer(buffer, maxSize, "PRODUCER");
Thread consumer = new Consumer(buffer, maxSize, "CONSUMER");<span style="font-family: Arial, Helvetica, sans-serif;"> </span>

<span style="font-family: Arial, Helvetica, sans-serif;"> //开启生产者和消费者线程</span>

producer.start(); 

consumer.start(); }
}

//生产者线程
class Producer extends Thread
{ private Queue<Integer> queue;
private int maxSize;
public Producer(Queue<Integer> queue, int maxSize, String name){
super(name); this.queue = queue; this.maxSize = maxSize;
}
@Override public void run()
{
while (true)
{
synchronized (queue) {
while (queue.size() == maxSize) { //当缓存区满的时候
try {
//进入wait
queue.wait();
} catch (Exception ex) {
ex.printStackTrace(); 

}
} 

//缓存区不为空的时候就可以继续生产，生产后唤醒消费者线程的wait
queue.add(i); 

queue.notifyAll();
}
}
}
}

//消费者线程
class Consumer extends Thread {
private Queue<Integer> queue;
private int maxSize;
public Consumer(Queue<Integer> queue, int maxSize, String name){
super(name);
this.queue = queue;
this.maxSize = maxSize;
}
@Override public void run() {
while (true) {
synchronized (queue) {
while (queue.isEmpty()) { //当缓存区为空的时候

try {
queue.wait(); //进入wait
} catch (Exception ex) {
ex.printStackTrace();
}
} 

//当缓存区不为空的时候，就可以唤醒所有的wait的消费者线程或者生产者线程
queue.notifyAll();
}
}
}
}

所以从以上可以看出，notify()实际上是可以实现线程间通信，可以在一个线程里通知唤醒另一个线程里的wait，实质上也是因为他们 wait和notify操作的是同一对象，这也是因为wait和notify是相对于Object的。

这就是利用wait和notify实现生产者和消费者问题。