JAVA多线程生产者消费者模式及实现方法

刺骨的言语ヽ痛彻心扉 2022-05-21 06:40 182阅读 0赞

# 1 生产者消费者模式 #

首先来了解什么是生产者消费者模式。该模式也称有限缓冲问题（英语：Bounded-buffer problem），是一个多线程同步问题的经典案例。该问题描述了两个共享固定大小缓冲区的线程——即所谓的“生产者”和“消费者”——在实际运行时会发生的问题。生产者的主要作用是生成一定量的数据放到缓冲区中，然后重复此过程。与此同时，消费者也在缓冲区消耗这些数据。**该问题的关键就是要保证生产者不会在缓冲区满时加入数据，消费者也不会在缓冲区中空时消耗数据。**

要解决该问题，就必须让生产者在缓冲区满时休眠（要么干脆就放弃数据），等到下次消费者消耗缓冲区中的数据的时候，生产者才能被唤醒，开始往缓冲区添加数据。同样，也可以让消费者在缓冲区空时进入休眠，等到生产者往缓冲区添加数据之后，再唤醒消费者。通常采用进程间通信的方法解决该问题，常用的方法有信号灯法等。如果解决方法不够完善，则容易出现死锁的情况。出现死锁时，两个线程都会陷入休眠，等待对方唤醒自己。该问题也能被推广到多个生产者和消费者的情形。

# 2 用wait和notify实现 #

这种方法的基本原理是：一个线程负责生产数据，放到共享区域，然后通知另一个线程去消耗数据。如果没有wait()和notify(),消费者线程就要不停去检查是否有数据被产生。

接下来介绍一下wait()和notify()，在这里把它们和sleep()做一个对比，方便理解

<table> 
 <thead> 
  <tr> 
   <th>不同点</th> 
   <th align="left">sleep()</th> 
   <th>wait()和notify()</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>原理</td> 
   <td align="left">线程用来控制自身流程，会使该线程暂停执行一段时间，把执行机会让给其它线程。时间一到就复苏。</td> 
   <td>是Object类的方法，会使当前拥有该对象锁的进程等待，直到其他线程调用notify()方法。</td> 
  </tr> 
  <tr> 
   <td>锁的处理机制</td> 
   <td align="left">只是让线程暂停执行一段时间，不会释放锁</td> 
   <td>调用wait()，线程会释放掉锁</td> 
  </tr> 
  <tr> 
   <td>使用区域</td> 
   <td align="left">可以放在任何地方</td> 
   <td>同步控制方法或者同步语句块中</td> 
  </tr> 
  <tr> 
   <td>异常</td> 
   <td align="left">必须捕获异常，例如InterruptedException等</td> 
   <td>不用捕获异常</td> 
  </tr> 
 </tbody> 
</table>

# wait(),notify(),notifyAll()必须在同步方法/代码块中调用 #

在Java中，所有对象都能够被作为"监视器monitor"——指一个拥有一个独占锁，一个入口队列和一个等待队列的实体entity。所有对象的非同步方法都能够在任意时刻被任意线程调用，此时不需要考虑加锁的问题。而对于对象的同步方法来说，在任意时刻有且仅有一个拥有该对象独占锁的线程能够调用它们。例如，一个同步方法是独占的。如果在线程调用某一对象的同步方法时，对象的独占锁被其他线程拥有，那么当前线程将处于阻塞状态，并添加到对象的入口队列中。

只有在调用线程拥有某个对象的独占锁时，才能够调用该对象的wait(),notify()和notifyAll()方法。这一点通常不会被程序员注意，因为程序验证通常是在对象的同步方法或同步代码块中调用它们的。如果尝试在未获取对象锁时调用这三个方法，那么你将得到一个"java.lang.IllegalMonitorStateException:current thread not owner"。

当一个线程正在某一个对象的同步方法中运行时调用了这个对象的wait()方法，那么这个线程将释放该对象的独占锁并被放入这个对象的等待队列。注意，wait()方法强制当前线程释放对象锁。这意味着在调用某对象的wait()方法之前，当前线程必须已经获得该对象的锁。因此，线程必须在某个对象的同步方法或同步代码块中才能调用该对象的wait()方法。

当某线程调用某对象的notify()或notifyAll()方法时，任意一个(对于notify())或者所有(对于notifyAll())在该对象的等待队列中的线程，将被转移到该对象的入口队列。接着这些队列(译者注:可能只有一个)将竞争该对象的锁，最终获得锁的线程继续执行。如果没有线程在该对象的等待队列中等待获得锁，那么notify()和notifyAll()将不起任何作用。在调用对象的notify()和notifyAll()方法之前，调用线程必须已经得到该对象的锁。因此，必须在某个对象的同步方法或同步代码块中才能调用该对象的notify()或notifyAll()方法。

对于处于某对象的等待队列中的线程，只有当其他线程调用此对象的notify()或notifyAll()方法时才有机会继续执行。

调用wait()方法的原因通常是，调用线程希望某个特殊的状态(或变量)被设置之后再继续执行。调用notify()或notifyAll()方法的原因通常是，调用线程希望告诉其他等待中的线程:"特殊状态已经被设置"。这个状态作为线程间通信的通道，它必须是一个可变的共享状态(或变量)。

例如，生产者线程向缓冲区中写入数据，消费者线程从缓冲区中读取数据。消费者线程需要等待直到生产者线程完成一次写入操作。生产者线程需要等待消费者线程完成一次读取操作。假设wait(),notify(),notifyAll()方法不需要加锁就能够被调用。此时消费者线程调用wait()正在进入状态变量的等待队列(译者注:可能还未进入)。在同一时刻，生产者线程调用notify()方法打算向消费者线程通知状态改变。那么此时消费者线程将错过这个通知并一直阻塞。因此，对象的wait(),notify(),notifyAll()方法必须在该对象的同步方法或同步代码块中被互斥地调用。

**wait()与sleep()的区别**  
**sleep()方法**是Thread类的静态方法，不涉及到线程间同步概念，仅仅为了让一个线程自身获得一段沉睡时间。sleep可以在任何地方使用。  
**wait()方法**是object类的方法，解决的问题是线程间的同步，该过程包含了同步锁的获取和释放，调用wait方法将会将调用者的线程挂起，直到其他线程调用同一个对象的notify()方法才会重新激活调用者。  
**注意:**线程调用notify()之后，只有该线程完全从 synchronized代码里面执行完毕后，monitor才会被释放，被唤醒线程才可以真正得到执行权。

sleep不会释放锁，容易导致死锁（）。因此推荐使用wait()和notify()。下面转载代码,

import java.util.LinkedList;
    import java.util.Queue;
    import org.apache.log4j.Logger;
    
    public class InterThreadCommunicationExample { 
    
        public static void main(String args[]) {
    
            final Queue sharedQ = new LinkedList();
    
            Thread producer = new Producer(sharedQ);
            Thread consumer = new Consumer(sharedQ);
    
            producer.start();
            consumer.start();
    
        }
    }
    
    public class Producer extends Thread { 
        private static final Logger logger = Logger.getLogger(Producer.class);
        private final Queue sharedQ;
    
        public Producer(Queue sharedQ) {
            super("Producer");
            this.sharedQ = sharedQ;
        }
    
        @Override
        public void run() {
    
            for (int i = 0; i < 4; i++) {
    
                synchronized (sharedQ) {
                    //waiting condition - wait until Queue is not empty
                    while (sharedQ.size() >= 1) {
                        try {
                            logger.debug("Queue is full, waiting");
                            sharedQ.wait();
                        } catch (InterruptedException ex) {
                            ex.printStackTrace();
                        }
                    }
                    logger.debug("producing : " + i);
                    sharedQ.add(i);
                    sharedQ.notify();
                }
            }
        }
    }
    
    public class Consumer extends Thread { 
        private static final Logger logger = Logger.getLogger(Consumer.class);
        private final Queue sharedQ;
    
        public Consumer(Queue sharedQ) {
            super("Consumer");
            this.sharedQ = sharedQ;
        }
    
        @Override
        public void run() {
            while(true) {
    
                synchronized (sharedQ) {
                    //waiting condition - wait until Queue is not empty
                    while (sharedQ.size() == 0) {
                        try {
                            logger.debug("Queue is empty, waiting");
                            sharedQ.wait();
                        } catch (InterruptedException ex) {
                            ex.printStackTrace();
                        }
                    }
                    int number = sharedQ.poll();
                    logger.debug("consuming : " + number );
                    sharedQ.notify();
    
                    //termination condition
                    if(number == 3){
       break; }
                }
            }
        }
    }
    
    Output:
    05:41:57,244 0    [Producer] DEBUG concurrency.Producer  - producing : 0
    05:41:57,260 16   [Producer] DEBUG concurrency.Producer  - Queue is full, waiting
    05:41:57,260 16   [Consumer] DEBUG concurrency.Consumer  - consuming : 0
    05:41:57,260 16   [Consumer] DEBUG concurrency.Consumer  - Queue is empty, waiting
    05:41:57,260 16   [Producer] DEBUG concurrency.Producer  - producing : 1
    05:41:57,260 16   [Producer] DEBUG concurrency.Producer  - Queue is full, waiting
    05:41:57,260 16   [Consumer] DEBUG concurrency.Consumer  - consuming : 1
    05:41:57,260 16   [Consumer] DEBUG concurrency.Consumer  - Queue is empty, waiting
    05:41:57,260 16   [Producer] DEBUG concurrency.Producer  - producing : 2
    05:41:57,260 16   [Producer] DEBUG concurrency.Producer  - Queue is full, waiting
    05:41:57,260 16   [Consumer] DEBUG concurrency.Consumer  - consuming : 2
    05:41:57,260 16   [Consumer] DEBUG concurrency.Consumer  - Queue is empty, waiting
    05:41:57,260 16   [Producer] DEBUG concurrency.Producer  - producing : 3
    05:41

# 3 使用阻塞队列实现 #

使用wait()和notify()是经典方法，这里介绍一个高级方法。

BlockingQueue中提供了put()和take()方法，可以极大简化生产者消费者模式的实现过程。这一过程的基本原理是，如果队列满了，put()方法就会被阻塞；如果队列是空的，take()方法会阻塞。与传统的wait()和notify()方法相比，使用阻塞队列更简单，更便于理解。下面是一个简单的例子：

import java.util.concurrent.BlockingQueue;
    import java.util.concurrent.LinkedBlockingQueue;
    import java.util.logging.Level;
    import java.util.logging.Logger;
    
    public class ProducerConsumerPattern { 
    
        public static void main(String args[]){
    
         //Creating shared object
         BlockingQueue sharedQueue = new LinkedBlockingQueue();
    
         //Creating Producer and Consumer Thread
         Thread prodThread = new Thread(new Producer(sharedQueue));
         Thread consThread = new Thread(new Consumer(sharedQueue));
    
         //Starting producer and Consumer thread
         prodThread.start();
         consThread.start();
        }
    
    }
    
    //Producer Class in java
    class Producer implements Runnable { 
    
        private final BlockingQueue sharedQueue;
    
        public Producer(BlockingQueue sharedQueue) {
            this.sharedQueue = sharedQueue;
        }
    
        @Override
        public void run() {
            for(int i=0; i<10; i++){
                try {
                    System.out.println("Produced: " + i);
                    sharedQueue.put(i);
                } catch (InterruptedException ex) {
                    Logger.getLogger(Producer.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
        }
    
    }
    
    //Consumer Class in Java
    class Consumer implements Runnable{ 
    
        private final BlockingQueue sharedQueue;
    
        public Consumer (BlockingQueue sharedQueue) {
            this.sharedQueue = sharedQueue;
        }
    
        @Override
        public void run() {
            while(true){
                try {
                    System.out.println("Consumed: "+ sharedQueue.take());
                } catch (InterruptedException ex) {
                    Logger.getLogger(Consumer.class.getName()).log(Level.SEVERE, null, ex);
                }
            }
        }
    
    
    }
    
    Output:
    Produced: 0
    Produced: 1
    Consumed: 0
    Produced: 2
    Consumed: 1
    Produced: 3
    Consumed: 2
    Produced: 4
    Consumed: 3
    Produced: 5
    Consumed: 4
    Produced: 6
    Consumed: 5
    Produced: 7
    Consumed: 6
    Produced: 8
    Consumed: 7
    Produced: 9
    Consumed: 8
    Consumed: 9