生产者/消费者问题的多种Java实现方式
Posted
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了生产者/消费者问题的多种Java实现方式相关的知识,希望对你有一定的参考价值。
实质上,很多后台服务程序并发控制的基本原理都可以归纳为生产者/消费者模式,
生产者消费者问题是研究多线程程序时绕不开的经典问题之一,它描述是有一块缓冲区作为仓库,生产者可以将产品放入仓库,消费者则可以从仓库中取走产品。解决生产者/消费者问题的方法可分为两类:
(1)采用某种机制保护生产者和消费者之间的同步;
(2)在生产者和消费者之间建立一个管道。第一种方式有较高的效率,并且易于实现,代码的可控制性较好,属于常用的模式。第二种管道缓冲区不易控制,被传输数据对象不易于封装等,实用性不强。因此本文只介绍同步机制实现的生产者/消费者问题。
同步问题核心在于:如何保证同一资源被多个线程并发访问时的完整性。常用的同步方法是采用信号或加锁机制,保证资源在任意时刻至多被一个线程访问。
Java语言在多线程编程上实现了完全对象化,提供了对同步机制的良好支持。在Java中一共有四种方法支持同步,其中前三个是同步方法,一个是管道方法。
(1)wait() / notify()方法
(2)await() / signal()方法
(3)BlockingQueue阻塞队列方法
(4)PipedInputStream / PipedOutputStream
本文只介绍最常用的前三种,第四种暂不做讨论,有兴趣的读者可以自己去网上找答案。
一、wait() / notify()方法
wait() / nofity()方法是基类Object的两个方法,也就意味着所有Java类都会拥有这两个方法,这样,我们就可以为任何对象实现同步机制。
wait()方法:当缓冲区已满/空时,生产者/消费者线程停止自己的执行,放弃锁,使自己处于等等状态,让其他线程执行。
notify()方法:当生产者/消费者向缓冲区放入/取出一个产品时,向其他等待的线程发出可执行的通知,同时放弃锁,使自己处于等待状态。
光看文字可能不太好理解,咱来段代码就明白了:
- import java.util.LinkedList;
- /**
- * 仓库类Storage实现缓冲区
- *
- * Email:[email protected]
- *
- * @author MONKEY.D.MENG 2011-03-15
- *
- */
- public class Storage
- {
- // 仓库最大存储量
- private final int MAX_SIZE = 100;
- // 仓库存储的载体
- private LinkedList<Object> list = new LinkedList<Object>();
- // 生产num个产品
- public void produce(int num)
- {
- // 同步代码段
- synchronized (list)
- {
- // 如果仓库剩余容量不足
- while (list.size() + num > MAX_SIZE)
- {
- System.out.println("【要生产的产品数量】:" + num + "/t【库存量】:"
- + list.size() + "/t暂时不能执行生产任务!");
- try
- {
- // 由于条件不满足,生产阻塞
- list.wait();
- }
- catch (InterruptedException e)
- {
- e.printStackTrace();
- }
- }
- // 生产条件满足情况下,生产num个产品
- for (int i = 1; i <= num; ++i)
- {
- list.add(new Object());
- }
- System.out.println("【已经生产产品数】:" + num + "/t【现仓储量为】:" + list.size());
- list.notifyAll();
- }
- }
- // 消费num个产品
- public void consume(int num)
- {
- // 同步代码段
- synchronized (list)
- {
- // 如果仓库存储量不足
- while (list.size() < num)
- {
- System.out.println("【要消费的产品数量】:" + num + "/t【库存量】:"
- + list.size() + "/t暂时不能执行生产任务!");
- try
- {
- // 由于条件不满足,消费阻塞
- list.wait();
- }
- catch (InterruptedException e)
- {
- e.printStackTrace();
- }
- }
- // 消费条件满足情况下,消费num个产品
- for (int i = 1; i <= num; ++i)
- {
- list.remove();
- }
- System.out.println("【已经消费产品数】:" + num + "/t【现仓储量为】:" + list.size());
- list.notifyAll();
- }
- }
- // get/set方法
- public LinkedList<Object> getList()
- {
- return list;
- }
- public void setList(LinkedList<Object> list)
- {
- this.list = list;
- }
- public int getMAX_SIZE()
- {
- return MAX_SIZE;
- }
- }
- /**
- * 生产者类Producer继承线程类Thread
- *
- * Email:[email protected]
- *
- * @author MONKEY.D.MENG 2011-03-15
- *
- */
- public class Producer extends Thread
- {
- // 每次生产的产品数量
- private int num;
- // 所在放置的仓库
- private Storage storage;
- // 构造函数,设置仓库
- public Producer(Storage storage)
- {
- this.storage = storage;
- }
- // 线程run函数
- public void run()
- {
- produce(num);
- }
- // 调用仓库Storage的生产函数
- public void produce(int num)
- {
- storage.produce(num);
- }
- // get/set方法
- public int getNum()
- {
- return num;
- }
- public void setNum(int num)
- {
- this.num = num;
- }
- public Storage getStorage()
- {
- return storage;
- }
- public void setStorage(Storage storage)
- {
- this.storage = storage;
- }
- }
- /**
- * 消费者类Consumer继承线程类Thread
- *
- * Email:[email protected]
- *
- * @author MONKEY.D.MENG 2011-03-15
- *
- */
- public class Consumer extends Thread
- {
- // 每次消费的产品数量
- private int num;
- // 所在放置的仓库
- private Storage storage;
- // 构造函数,设置仓库
- public Consumer(Storage storage)
- {
- this.storage = storage;
- }
- // 线程run函数
- public void run()
- {
- consume(num);
- }
- // 调用仓库Storage的生产函数
- public void consume(int num)
- {
- storage.consume(num);
- }
- // get/set方法
- public int getNum()
- {
- return num;
- }
- public void setNum(int num)
- {
- this.num = num;
- }
- public Storage getStorage()
- {
- return storage;
- }
- public void setStorage(Storage storage)
- {
- this.storage = storage;
- }
- }
- /**
- * 测试类Test
- *
- * Email:[email protected]
- *
- * @author MONKEY.D.MENG 2011-03-15
- *
- */
- public class Test
- {
- public static void main(String[] args)
- {
- // 仓库对象
- Storage storage = new Storage();
- // 生产者对象
- Producer p1 = new Producer(storage);
- Producer p2 = new Producer(storage);
- Producer p3 = new Producer(storage);
- Producer p4 = new Producer(storage);
- Producer p5 = new Producer(storage);
- Producer p6 = new Producer(storage);
- Producer p7 = new Producer(storage);
- // 消费者对象
- Consumer c1 = new Consumer(storage);
- Consumer c2 = new Consumer(storage);
- Consumer c3 = new Consumer(storage);
- // 设置生产者产品生产数量
- p1.setNum(10);
- p2.setNum(10);
- p3.setNum(10);
- p4.setNum(10);
- p5.setNum(10);
- p6.setNum(10);
- p7.setNum(80);
- // 设置消费者产品消费数量
- c1.setNum(50);
- c2.setNum(20);
- c3.setNum(30);
- // 线程开始执行
- c1.start();
- c2.start();
- c3.start();
- p1.start();
- p2.start();
- p3.start();
- p4.start();
- p5.start();
- p6.start();
- p7.start();
- }
- }
- 【要消费的产品数量】:50 【库存量】:0 暂时不能执行生产任务!
- 【要消费的产品数量】:30 【库存量】:0 暂时不能执行生产任务!
- 【要消费的产品数量】:20 【库存量】:0 暂时不能执行生产任务!
- 【已经生产产品数】:10 【现仓储量为】:10
- 【要消费的产品数量】:20 【库存量】:10 暂时不能执行生产任务!
- 【要消费的产品数量】:30 【库存量】:10 暂时不能执行生产任务!
- 【要消费的产品数量】:50 【库存量】:10 暂时不能执行生产任务!
- 【已经生产产品数】:10 【现仓储量为】:20
- 【要消费的产品数量】:50 【库存量】:20 暂时不能执行生产任务!
- 【要消费的产品数量】:30 【库存量】:20 暂时不能执行生产任务!
- 【已经消费产品数】:20 【现仓储量为】:0
- 【已经生产产品数】:10 【现仓储量为】:10
- 【已经生产产品数】:10 【现仓储量为】:20
- 【已经生产产品数】:80 【现仓储量为】:100
- 【要生产的产品数量】:10 【库存量】:100 暂时不能执行生产任务!
- 【已经消费产品数】:30 【现仓储量为】:70
- 【已经消费产品数】:50 【现仓储量为】:20
- 【已经生产产品数】:10 【现仓储量为】:30
- 【已经生产产品数】:10 【现仓储量为】:40
看完上述代码,对wait() / notify()方法实现的同步有了了解。你可能会对Storage类中为什么要定义public void produce(int num);和public void consume(int num);方法感到不解,为什么不直接在生产者类Producer和消费者类Consumer中实现这两个方法,却要调用Storage类中的实现呢?淡定,后文会有解释。我们先往下走。
二、await() / signal()方法
在JDK5.0之后,Java提供了更加健壮的线程处理机制,包括同步、锁定、线程池等,它们可以实现更细粒度的线程控制。await()和signal()就是其中用来做同步的两种方法,它们的功能基本上和wait() / nofity()相同,完全可以取代它们,但是它们和新引入的锁定机制Lock直接挂钩,具有更大的灵活性。通过在Lock对象上调用newCondition()方法,将条件变量和一个锁对象进行绑定,进而控制并发程序访问竞争资源的安全。下面来看代码:
- import java.util.LinkedList;
- import java.util.concurrent.locks.Condition;
- import java.util.concurrent.locks.Lock;
- import java.util.concurrent.locks.ReentrantLock;
- /**
- * 仓库类Storage实现缓冲区
- *
- * Email:[email protected]
- *
- * @author MONKEY.D.MENG 2011-03-15
- *
- */
- public class Storage
- {
- // 仓库最大存储量
- private final int MAX_SIZE = 100;
- // 仓库存储的载体
- private LinkedList<Object> list = new LinkedList<Object>();
- // 锁
- private final Lock lock = new ReentrantLock();
- // 仓库满的条件变量
- private final Condition full = lock.newCondition();
- // 仓库空的条件变量
- private final Condition empty = lock.newCondition();
- // 生产num个产品
- public void produce(int num)
- {
- // 获得锁
- lock.lock();
- // 如果仓库剩余容量不足
- while (list.size() + num > MAX_SIZE)
- {
- System.out.println("【要生产的产品数量】:" + num + "/t【库存量】:" + list.size()
- + "/t暂时不能执行生产任务!");
- try
- {
- // 由于条件不满足,生产阻塞
- full.await();
- }
- catch (InterruptedException e)
- {
- e.printStackTrace();
- }
- }
- // 生产条件满足情况下,生产num个产品
- for (int i = 1; i <= num; ++i)
- {
- list.add(new Object());
- }
- System.out.println("【已经生产产品数】:" + num + "/t【现仓储量为】:" + list.size());
- // 唤醒其他所有线程
- full.signalAll();
- empty.signalAll();
- // 释放锁
- lock.unlock();
- }
- // 消费num个产品
- public void consume(int num)
- {
- // 获得锁
- lock.lock();
- // 如果仓库存储量不足
- while (list.size() < num)
- {
- System.out.println("【要消费的产品数量】:" + num + "/t【库存量】:" + list.size()
- + "/t暂时不能执行生产任务!");
- try
- {
- // 由于条件不满足,消费阻塞
- empty.await();
- }
- catch (InterruptedException e)
- {
- e.printStackTrace();
- }
- }
- // 消费条件满足情况下,消费num个产品
- for (int i = 1; i <= num; ++i)
- {
- list.remove();
- }
- System.out.println("【已经消费产品数】:" + num + "/t【现仓储量为】:" + list.size());
- // 唤醒其他所有线程
- full.signalAll();
- empty.signalAll();
- // 释放锁
- lock.unlock();
- }
- // set/get方法
- public int getMAX_SIZE()
- {
- return MAX_SIZE;
- }
- public LinkedList<Object> getList()
- {
- return list;
- }
- public void setList(LinkedList<Object> list)
- {
- this.list = list;
- }
- }
- 【要消费的产品数量】:50 【库存量】:0 暂时不能执行生产任务!
- 【要消费的产品数量】:30 【库存量】:0 暂时不能执行生产任务!
- 【已经生产产品数】:10 【现仓储量为】:10
- 【已经生产产品数】:10 【现仓储量为】:20
- 【要消费的产品数量】:50 【库存量】:20 暂时不能执行生产任务!
- 【要消费的产品数量】:30 【库存量】:20 暂时不能执行生产任务!
- 【已经生产产品数】:10 【现仓储量为】:30
- 【要消费的产品数量】:50 【库存量】:30 暂时不能执行生产任务!
- 【已经消费产品数】:20 【现仓储量为】:10
- 【已经生产产品数】:10 【现仓储量为】:20
- 【要消费的产品数量】:30 【库存量】:20 暂时不能执行生产任务!
- 【已经生产产品数】:80 【现仓储量为】:100
- 【要生产的产品数量】:10 【库存量】:100 暂时不能执行生产任务!
- 【已经消费产品数】:50 【现仓储量为】:50
- 【已经生产产品数】:10 【现仓储量为】:60
- 【已经消费产品数】:30 【现仓储量为】:30
- 【已经生产产品数】:10 【现仓储量为】:40
只需要更新仓库类Storage的代码即可,生产者Producer、消费者Consumer、测试类Test的代码均不需要进行任何更改。这样我们就知道为神马我要在Storage类中定义public void produce(int num);和public void consume(int num);方法,并在生产者类Producer和消费者类Consumer中调用Storage类中的实现了吧。将可能发生的变化集中到一个类中,不影响原有的构架设计,同时无需修改其他业务层代码。无意之中,我们好像使用了某种设计模式,具体是啥我忘记了,啊哈哈,等我想起来再告诉大家~
三、BlockingQueue阻塞队列方法
BlockingQueue是JDK5.0的新增内容,它是一个已经在内部实现了同步的队列,实现方式采用的是我们第2种await() / signal()方法。它可以在生成对象时指定容量大小。它用于阻塞操作的是put()和take()方法。
put()方法:类似于我们上面的生产者线程,容量达到最大时,自动阻塞。
take()方法:类似于我们上面的消费者线程,容量为0时,自动阻塞。
关于BlockingQueue的内容网上有很多,大家可以自己搜,我在这不多介绍。下面直接看代码,跟以往一样,我们只需要更改仓库类Storage的代码即可:
- import java.util.concurrent.LinkedBlockingQueue;
- /**
- * 仓库类Storage实现缓冲区
- *
- * Email:[email protected]
- *
- * @author MONKEY.D.MENG 2011-03-15
- *
- */
- public class Storage
- {
- // 仓库最大存储量
- private final int MAX_SIZE = 100;
- // 仓库存储的载体
- private LinkedBlockingQueue<Object> list = new LinkedBlockingQueue<Object>(
- 100);
- // 生产num个产品
- public void produce(int num)
- {
- // 如果仓库剩余容量为0
- if (list.size() == MAX_SIZE)
- {
- System.out.println("【库存量】:" + MAX_SIZE + "/t暂时不能执行生产任务!");
- }
- // 生产条件满足情况下,生产num个产品
- for (int i = 1; i <= num; ++i)
- {
- try
- {
- // 放入产品,自动阻塞
- list.put(new Object());
- }
- catch (InterruptedException e)
- {
- e.printStackTrace();
- }
- System.out.println("【现仓储量为】:" + list.size());
- }
- }
- // 消费num个产品
- public void consume(int num)
- {
- // 如果仓库存储量不足
- if (list.size() == 0)
- {
- System.out.println("【库存量】:0/t暂时不能执行生产任务!");
- }
- // 消费条件满足情况下,消费num个产品
- for (int i = 1; i <= num; ++i)
- {
- try
- {
- // 消费产品,自动阻塞
- list.take();
- }
- catch (InterruptedException e)
- {
- e.printStackTrace();
- }
- }
- System.out.println("【现仓储量为】:" + list.size());
- }
- // set/get方法
- public LinkedBlockingQueue<Object> getList()
- {
- return list;
- }
- public void setList(LinkedBlockingQueue<Object> list)
- {
- this.list = list;
- }
- public int getMAX_SIZE()
- {
- return MAX_SIZE;
- }
- }
- 【库存量】:0 暂时不能执行生产任务!
- 【库存量】:0 暂时不能执行生产任务!
- 【现仓储量为】:1
- 【现仓储量为】:1
- 【现仓储量为】:3
- 【现仓储量为】:4
- 【现仓储量为】:5
- 【现仓储量为】:6
- 【现仓储量为】:7
- 【现仓储量为】:8
- 【现仓储量为】:9
- 【现仓储量为】:10
- 【现仓储量为】:11
- 【现仓储量为】:1
- 【现仓储量为】:2
- 【现仓储量为】:13
- 【现仓储量为】:14
- 【现仓储量为】:17
- 【现仓储量为】:19
- 【现仓储量为】:20
- 【现仓储量为】:21
- 【现仓储量为】:22
- 【现仓储量为】:23
- 【现仓储量为】:24
- 【现仓储量为】:25
- 【现仓储量为】:26
- 【现仓储量为】:12
- 【现仓储量为】:1
- 【现仓储量为】:1
- 【现仓储量为】:2
- 【现仓储量为】:3
- 【现仓储量为】:4
- 【现仓储量为】:5
- 【现仓储量为】:6
- 【现仓储量为】:7
- 【现仓储量为】:27
- 【现仓储量为】:8
- 【现仓储量为】:6
- 【现仓储量为】:18
- 【现仓储量为】:2
- 【现仓储量为】:3
- 【现仓储量为】:4
- 【现仓储量为】:5
- 【现仓储量为】:6
- 【现仓储量为】:7
- 【现仓储量为】:8
- 【现仓储量为】:9
- 【现仓储量为】:10
- 【现仓储量为】:16
- 【现仓储量为】:11
- 【现仓储量为】:12
- 【现仓储量为】:13
- 【现仓储量为】:14
- 【现仓储量为】:15
- 【现仓储量为】:1
- 【现仓储量为】:2
- 【现仓储量为】:3
- 【现仓储量为】:3
- 【现仓储量为】:15
- 【现仓储量为】:1
- 【现仓储量为】:0
- 【现仓储量为】:1
- 【现仓储量为】:1
- 【现仓储量为】:1
- 【现仓储量为】:2
- 【现仓储量为】:3
- 【现仓储量为】:4
- 【现仓储量为】:0
- 【现仓储量为】:1
- 【现仓储量为】:5
- 【现仓储量为】:6
- 【现仓储量为】:7
- 【现仓储量为】:8
- 【现仓储量为】:9
- 【现仓储量为】:10
- 【现仓储量为】:11
- 【现仓储量为】:12
- 【现仓储量为】:13
- 【现仓储量为】:14
- 【现仓储量为】:15
- 【现仓储量为】:16
- 【现仓储量为】:17
- 【现仓储量为】:1
- 【现仓储量为】:1
- 【现仓储量为】:2
- 【现仓储量为】:3
- 【现仓储量为】:4
- 【现仓储量为】:5
- 【现仓储量为】:6
- 【现仓储量为】:3
- 【现仓储量为】:3
- 【现仓储量为】:1
- 【现仓储量为】:2
- 【现仓储量为】:3
- 【现仓储量为】:4
- 【现仓储量为】:5
- 【现仓储量为】:6
- 【现仓储量为】:7
- 【现仓储量为】:8
- 【现仓储量为】:9
- 【现仓储量为】:10
- 【现仓储量为】:11
- 【现仓储量为】:12
- 【现仓储量为】:13
- 【现仓储量为】:14
- 【现仓储量为】:15
- 【现仓储量为】:16
- 【现仓储量为】:17
- 【现仓储量为】:18
- 【现仓储量为】:19
- 【现仓储量为】:6
- 【现仓储量为】:7
- 【现仓储量为】:8
- 【现仓储量为】:9
- 【现仓储量为】:10
- 【现仓储量为】:11
- 【现仓储量为】:12
- 【现仓储量为】:13
- 【现仓储量为】:14
- 【现仓储量为】:15
- 【现仓储量为】:16
- 【现仓储量为】:17
- 【现仓储量为】:18
- 【现仓储量为】:19
- 【现仓储量为】:20
- 【现仓储量为】:21
- 【现仓储量为】:22
- 【现仓储量为】:23
- 【现仓储量为】:24
- 【现仓储量为】:25
- 【现仓储量为】:26
- 【现仓储量为】:27
- 【现仓储量为】:28
- 【现仓储量为】:29
- 【现仓储量为】:30
- 【现仓储量为】:31
- 【现仓储量为】:32
- 【现仓储量为】:33
- 【现仓储量为】:34
- 【现仓储量为】:35
- 【现仓储量为】:36
- 【现仓储量为】:37
- 【现仓储量为】:38
- 【现仓储量为】:39
- 【现仓储量为】:40
当然,你会发现这时对于public void produce(int num);和public void consume(int num);方法业务逻辑上的实现跟前面两个例子不太一样,没关系,这个例子只是为了说明BlockingQueue阻塞队列的使用。
有时使用BlockingQueue可能会出现put()和System.out.println()输出不匹配的情况,这是由于它们之间没有同步造成的。当缓冲区已满,生产者在put()操作时,put()内部调用了await()方法,放弃了线程的执行,然后消费者线程执行,调用take()方法,take()内部调用了signal()方法,通知生产者线程可以执行,致使在消费者的println()还没运行的情况下生产者的println()先被执行,所以有了输出不匹配的情况。
对于BlockingQueue大家可以放心使用,这可不是它的问题,只是在它和别的对象之间的同步有问题。
以上是关于生产者/消费者问题的多种Java实现方式的主要内容,如果未能解决你的问题,请参考以下文章
Carson带你学Java:解决生产者消费者问题的五种实现方式
Carson带你学Java:解决生产者消费者问题的五种实现方式