Java 生产者模式 消费者模式

 // The standard idiom for calling the wait
 synchronized(sharedObject) {
        while(condition){
             sharedObject.wait();// Releases lock, and reacquires on wake up
        }
        // do action based upon condition e.g. take or put into queue
 }

使用wait和notify函数的规范代码模版。

在while循环里使用wait的目的：是在线程被唤醒前后都持续检查条件是否被满足，如果条件并未改变，wait被调用之前notify的唤醒通知就来了，那个这个线程并不能保证被唤醒，有坑会导致死锁的问题。

 public class ProducerConsumer {
       public static void main (String args[]) {
             Queue<Integer> buffer = new LinkedList<>();
             int maxSize = 10;
             Thread producer = new Producer(buffer, maxSize, "PRODUCER");
             Thread consumer = new Producer(buffer, maxSize, "CONSUMER");
             producer.start();
             consumer.start();
       }
 }    

在上面代码中，声明了一个LinkedList作为缓冲区队列（在java中，LinkedList实现了队列的接口）。

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 {
                                    // Queue is full
                                    // Producer thread waiting for
                                    // consumer to take something from queue
                                    queue.wait();
                              } catch (Exception e) {
                                    e.printStackTrace();
                              }
                              Random random = new Random();
                              int producerValue = random.nextInt();
                              queue.add(producerValue);
                              queue.notifyAll();
                        }
                 }
           }
      }
}

如上代码为生产者，其在无限循环中持续往LinkedList里插入随机整数直到LinkedList满。如果队列满了，那么生产者线程会在消费者线程消耗掉队列里的任意一个整数，并用notify通知生产者线程之前持续等待。

 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()) {
                              // queue is empty;
                              // Consumer thread is waiting
                              // for producer thread to put something in queue
                              try {
                                    queue.wait();
                              } catch (Exception e) {
                                    e.printStackTrace();
                              }
                              print("Consumer value : " + queue remove());
                              queue.notifyAll();
                       }
                 }
           }
     }
 }

注意：

1. 你可以使用wait和notify函数来实现线程间通信，你可以用它们来实现多线程之间的通信。

2. 永远在synchronized的函数或者对象里使用wait、notify、notifyAll，不然java虚拟机会生成IllgalMonitorStateException。

3. 永远在while循环里而不是在if语句下使用wait，这样，循环会在线程睡眠前后都检查wait的条件，并在条件实际上并未改变的情况下处理唤醒通知。

4. 永远在多线程间共享的对象（生产者消费者模型里即缓冲区队列）上使用wait。

Producer - Consumer Pattern:

Consumer:

sunchronized (obj) {
     while (!workToDo) {
           obj.wait();
     }
     // get next item from this queue
     workToDo = false;
}
// do work on the item

Producer:

 synchronized (obj) {
       if (!workToDo) {
            // add work to queue
            workToDo = true;
       }
       obj.notifyAll();
 }