Java多线程14：生产者/消费者模型

旧城等待， 2022-05-25 07:39 210阅读 0赞

转自：http://www.cnblogs.com/xrq730/p/4855663.html

什么是生产者/消费者模型

一种重要的模型，基于等待/通知机制。生产者/消费者模型描述的是有一块缓冲区作为仓库，生产者可将产品放入仓库，消费者可以从仓库中取出产品，生产者/消费者模型关注的是以下几个点：

*  生产者生产的时候消费者不能消费
 *  消费者消费的时候生产者不能生产
 *  缓冲区空时消费者不能消费
 *  缓冲区满时生产者不能生产

生产者/模型作为一种重要的模型，它的优点在于：

*  解耦。因为多了一个缓冲区，所以生产者和消费者并不直接相互调用，这一点很容易想到，这样生产者和消费者的代码发生变化，都不会对对方产生影响，这样其实就把生产者和消费者之间的强耦合解开，变为了生产者和缓冲区/消费者和缓冲区之间的弱耦合
 *  通过平衡生产者和消费者的处理能力来提高整体处理数据的速度，这是生产者/消费者模型最重要的一个优点。如果消费者直接从生产者这里拿数据，如果生产者生产的速度很慢，但消费者消费的速度很快，那消费者就得占用CPU的时间片白白等在那边。有了生产者/消费者模型，生产者和消费者就是两个独立的并发体，生产者把生产出来的数据往缓冲区一丢就好了，不必管消费者；消费者也是，从缓冲区去拿数据就好了，也不必管生产者，缓冲区满了就不生产，缓冲区空了就不消费，使生产者/消费者的处理能力达到一个动态的平衡

利用wait()/notify()实现生产者/消费者模型

既然生产者/消费者模型有一个缓冲区，那么我们就自己做一个缓冲区，生产者和消费者的通信都是通过这个缓冲区的。value为""表示缓冲区空，value不为""表示缓冲区满：

public class ValueObject
    {
        public static String value = "";
    }

接下来就是一个生产者了，如果缓冲区满了的，那么就wait()，不再生产了，等待消费者消费完通知；如果缓冲区是空的，那么就生产数据到缓冲区中

![复制代码][copycode.gif]

public class Producer
    {
        private Object lock;
        
        public Producer(Object lock)
        {
            this.lock = lock;
        }
        
        public void setValue()
        {
            try
            {
                synchronized (lock)
                {
                    if (!ValueObject.value.equals(""))
                        lock.wait();
                    String value = System.currentTimeMillis() + "_" + System.nanoTime();
                    System.out.println("Set的值是：" + value);
                    ValueObject.value = value;
                    lock.notify();
                }
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
        }
    }

![复制代码][copycode.gif]

消费者类似，如果缓冲区是空的，那么就不再消费，wait()等待，等待生产者生产完通知；如果缓冲区不是空的，那么就去拿数据：

![复制代码][copycode.gif]

public class Customer
    {
        private Object lock;
        
        public Customer(Object lock)
        {
            this.lock = lock;
        }
        
        public void getValue()
        {
            try
            {
                synchronized (lock)
                {
                    if (ValueObject.value.equals(""))
                        lock.wait();
                    System.out.println("Get的值是：" + ValueObject.value);
                    ValueObject.value = "";
                    lock.notify();
                }
            } 
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
        }
    }

![复制代码][copycode.gif]

写个主函数，开两个线程调用Producer里面的getValue()方法和Customer()里面的setValue()方法：

![复制代码][copycode.gif]

public static void main(String[] args)
    {
        Object lock = new Object();
        final Producer producer = new Producer(lock);
        final Customer customer = new Customer(lock);
        Runnable producerRunnable = new Runnable()
        {
            public void run()
            {
                while (true)
                {
                    producer.setValue();
                }
            }
        };
        Runnable customerRunnable = new Runnable()
        {
            public void run()
            {
                while (true)
                {
                    customer.getValue();
                }
            }
        };
        Thread producerThread = new Thread(producerRunnable);
        Thread CustomerThread = new Thread(customerRunnable);
        producerThread.start();
        CustomerThread.start();
    }

![复制代码][copycode.gif]

看一下运行结果：

![复制代码][copycode.gif]

...
    Set的值是：1444025677743_162366875965845
    Get的值是：1444025677743_162366875965845
    Set的值是：1444025677743_162366875983541
    Get的值是：1444025677743_162366875983541
    Set的值是：1444025677743_162366876004776
    Get的值是：1444025677743_162366876004776
    ...

![复制代码][copycode.gif]

生产数据和消费数据一定是成对出现的，生产一个消费一个，满了不生产，空了不消费，生产者不能无限生产，消费者也不能无限消费，符合生产者/消费者模型。生产者速度快，就不占用CPU时间片，等着消费者消费完通知它继续生产，这块时间片可以用来给其他线程用。

利用await()/signal()实现生产者和消费者模型

一样，先定义一个缓冲区：

public class ValueObject
    {
        public static String value = "";
    }

换种写法，生产和消费方法放在一个类里面：

![复制代码][copycode.gif]

public class ThreadDomain41 extends ReentrantLock
    {
        private Condition condition = newCondition();
        
        public void set()
        {
            try
            {
                lock();
                while (!"".equals(ValueObject.value))
                    condition.await();
                ValueObject.value = "123";
                System.out.println(Thread.currentThread().getName() + "生产了value, value的当前值是" + ValueObject.value);
                condition.signal();
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
            finally
            {
                unlock();
            }
        }
        
        public void get()
        {
            try
            {
                lock();
                while ("".equals(ValueObject.value))
                    condition.await();
                ValueObject.value = "";
                System.out.println(Thread.currentThread().getName() + "消费了value, value的当前值是" + ValueObject.value);
                condition.signal();
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
            finally
            {
                unlock();
            }
        }
    }

![复制代码][copycode.gif]

同样的，开两个线程，一个线程调用set()方法生产，另一个线程调用get()方法消费：

![复制代码][copycode.gif]

public static void main(String[] args)
    {
        final ThreadDomain41 td = new ThreadDomain41();
        Runnable producerRunnable = new Runnable()
        {
            public void run()
            {
                for (int i = 0; i < Integer.MAX_VALUE; i++)
                    td.set();
            }
        };
        Runnable customerRunnable = new Runnable()
        {
            public void run()
            {
                for (int i = 0; i < Integer.MAX_VALUE; i++)
                    td.get();
            }
        };
        Thread ProducerThread = new Thread(producerRunnable);
        ProducerThread.setName("Producer");
        Thread ConsumerThread = new Thread(customerRunnable);
        ConsumerThread.setName("Consumer");
        ProducerThread.start();
        ConsumerThread.start();
    }

![复制代码][copycode.gif]

看一下运行结果：

![复制代码][copycode.gif]

...
    Producer生产了value, value的当前值是123
    Consumer消费了value, value的当前值是
    Producer生产了value, value的当前值是123
    Consumer消费了value, value的当前值是
    Producer生产了value, value的当前值是123
    Consumer消费了value, value的当前值是
    ...

![复制代码][copycode.gif]

和wait()/notify()机制的实现效果一样，同样符合生产者/消费者模型

小心假死

生产者/消费者模型最终达到的目的是平衡生产者和消费者的处理能力，达到这个目的的过程中，并不要求只有一个生产者和一个消费者。可以多个生产者对应多个消费者，可以一个生产者对应一个消费者，可以多个生产者对应一个消费者。

假死就发生在上面三种场景下。理论分析就能说明问题，所以就不写代码了。代码要写也很简单，上面的两个例子随便修改一个，开一个生产者线程/多个消费者线程、开多个生产者线程/消费者线程、开多个生产者线程/多个消费者线程都可以。假死指的是全部线程都进入了WAITING状态，那么程序就不再执行任何业务功能了，整个项目呈现停滞状态。

比方说有生产者A和生产者B，缓冲区由于空了，消费者处于WAITING。生产者B处于WAITING，生产者A被消费者通知生产，生产者A生产出来的产品本应该通知消费者，结果通知了生产者B，生产者B被唤醒，发现缓冲区满了，于是继续WAITING。至此，两个生产者线程处于WAITING，消费者处于WAITING，系统假死。

上面的分析可以看出，假死出现的原因是因为notify的是同类，所以非单生产者/单消费者的场景，可以采取两种方法解决这个问题：

1、synchronized用notifyAll()唤醒所有线程、ReentrantLock用signalAll()唤醒所有线程

2、用ReentrantLock定义两个Condition，一个表示生产者的Condition，一个表示消费者的Condition，唤醒的时候调用相应的Condition的signal()方法就可以了

[copycode.gif]: /images/20220525/975d55d3542c4757ad99f2a345343532.png