生产者消费者模式并不是GOF提出的23种设计模式之一，23种设计模式都是建立在面向对象的基础之上的，但其实面向过程的编程中也有很多高效的编程模式，生产者消费者模式便是其中之一，它是我们编程过程中最常用的一种设计模式。
在java应用中，生产者/消费者模式的实现有以下五种:
1:wait() / nofity()方法是基类Object的两个方法，也就意味着所有Java类都会拥有这两个方法，这样，我们就可以为任何对象实现同步机制。
2.await()和signal()就是其中用来做同步的两种方法，它们的功能基本上和wait() / nofity()相同。
3:BlockingQueue是JDK5.0的新增内容，它是一个已经在内部实现了同步的队列，实现方式采用的是我们第2种await() / signal()方法。
4:PipedOutputStream和PipedInputStream是管道输出流和管道输入流，配合使用可以实现线程间通信。
5:Semaphore除了控制资源的多个副本的并发访问控制，也可以使用二进制信号量来实现类似synchronized关键字和Lock锁的并发访问控制功能。
源码地址:https://github.com/followwwind/javadesign
下面对上面三种进行实现:
/** * @author wind */ public interface Storage { /** * 仓库最大存储量 */ int MAX_SIZE = 100; /** * 生产num个产品 * @param num */ void produce(int num); /** * 消费num个产品 * @param num */ void consume(int num); }
1.wait() / nofity()
/** * wait() / nofity()方法是基类Object的两个方法，也就意味着所有Java类都会拥有这两个方法，这样，我们就可以为任何对象实现同步机制。 * wait()方法：当缓冲区已满/空时，生产者/消费者线程停止自己的执行，放弃锁，使自己处于等等状态，让其他线程执行。 * notify()方法：当生产者/消费者向缓冲区放入/取出一个产品时，向其他等待的线程发出可执行的通知，同时放弃锁，使自己处于等待状态。 * @author wind */ public class StorageThree implements Storage{ /** * 仓库最大存储量 */ private final int MAX_SIZE = 100; /** * 仓库存储的载体 */ private LinkedList<Object> list = new LinkedList<>(); /** * 生产num个产品 * @param num */ @Override 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个产品 * @param num */ @Override 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(); } } public LinkedList<Object> getList() { return list; } public void setList(LinkedList<Object> list) { this.list = list; } }
2.await()和signal()
/** * 仓库类Storage实现缓冲区 * 在JDK5.0之后，Java提供了更加健壮的线程处理机制，包括同步、锁定、线程池等，它们可以实现更细粒度的线程控制。 * await()和signal()就是其中用来做同步的两种方法，它们的功能基本上和wait() / nofity()相同， * 完全可以取代它们，但是它们和新引入的锁定机制Lock直接挂钩，具有更大的灵活性。 * 通过在Lock对象上调用newCondition()方法，将条件变量和一个锁对象进行绑定，进而控制并发程序访问竞争资源的安全 * @author wind */ public class StorageOne implements Storage { /** * 仓库存储的载体 */ private LinkedList<Object> list = new LinkedList<>(); /** * 锁 */ private final Lock lock = new ReentrantLock(); /** * 仓库满的条件变量 */ private final Condition full = lock.newCondition(); /** * 仓库空的条件变量 */ private final Condition empty = lock.newCondition(); /** * 生产num个产品 * @param num */ @Override 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个产品 * @param num */ @Override 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(); } public LinkedList<Object> getList() { return list; } public void setList(LinkedList<Object> list) { this.list = list; } }3. BlockingQueue
/** * 仓库类Storage实现缓冲区 * BlockingQueue是JDK5.0的新增内容，它是一个已经在内部实现了同步的队列，实现方式采用的是我们第2种await() / signal()方法。 * 它可以在生成对象时指定容量大小。它用于阻塞操作的是put()和take()方法。 * put()方法：类似于我们上面的生产者线程，容量达到最大时，自动阻塞。 * take()方法：类似于我们上面的消费者线程，容量为0时，自动阻塞。 * @author wind */ public class StorageTwo implements Storage { /** * 仓库存储的载体 */ private LinkedBlockingQueue<Object> list = new LinkedBlockingQueue<>(MAX_SIZE); /** * 生产num个产品 * @param num */ @Override 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个产品 * @param num */ @Override 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()); } public LinkedBlockingQueue<Object> getList() { return list; } public void setList(LinkedBlockingQueue<Object> list) { this.list = list; } }
4.消费者类Consumer继承线程类Thread
public class Consumer extends Thread{ /** * 每次消费的产品数量 */ private int num; /** * 所在放置的仓库 */ private Storage storage; /** * 构造函数，设置仓库 * @param storage */ public Consumer(Storage storage) { this.storage = storage; } public Consumer(int num, Storage storage) { this.num = num; this.storage = storage; } /** * 线程run函数 */ @Override public void run() { consume(num); } /** * 调用仓库Storage的生产函数 * @param num */ public void consume(int num) { storage.consume(num); } 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; } }5.生产者类Producer继承线程类Thread
public class Producer extends Thread{ /** * 每次生产的产品数量 */ private int num; /** * 所在放置的仓库 */ private Storage storage; /** * 构造函数，设置仓库 * @param storage */ public Producer(Storage storage) { this.storage = storage; } public Producer(int num, Storage storage) { this.num = num; this.storage = storage; } /** * 线程run函数 */ @Override public void run() { produce(num); } /** * 调用仓库Storage的生产函数 * @param num */ public void produce(int num) { storage.produce(num); } 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; } }
6.测试
/** * 测试类 * @author wind */ public class Test { private static Storage getStorage(String name){ Storage storage = null; switch (name){ //await/signal case "one" : storage = new StorageOne(); break; //blockingqueue case "two" : storage = new StorageTwo(); break; //wait/nofity default: new StorageThree(); break; } return storage; } public static void main(String[] args) { // 仓库对象 Storage storage = getStorage("one"); // 生产者对象和产品生产数量 Producer p1 = new Producer(10, storage); Producer p2 = new Producer(10, storage); Producer p3 = new Producer(10, storage); Producer p4 = new Producer(10, storage); Producer p5 = new Producer(10, storage); Producer p6 = new Producer(10, storage); Producer p7 = new Producer(80, storage); // 消费者对象和产品消费数量 Consumer c1 = new Consumer(50, storage); Consumer c2 = new Consumer(20, storage); Consumer c3 = new Consumer(30, storage); // 线程开始执行 c1.start(); c2.start(); c3.start(); p1.start(); p2.start(); p3.start(); p4.start(); p5.start(); p6.start(); p7.start(); } }
467
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
