用Java实现 生产者/消费者问题

最新推荐文章于 2020-08-23 17:09:39 发布
最新推荐文章于 2020-08-23 17:09:39 发布
阅读量1.4k 收藏
点赞数
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bigtree_3721/article/details/39853225
版权

 

在Java中一共有四种方法支持同步，其中前三个是同步方法，一个是管道方法。

（1）wait() / notify()方法

（2）await() / signal()方法

（3）BlockingQueue阻塞队列方法

（4）PipedInputStream / PipedOutputStream

本人编写的JAVA代码只实现了最常用的前三种。JAVA代码在 eclipse 调试通过。

有一篇文章也不错，可以去看看

http://blog.csdn.net/monkey_d_meng/article/details/6251879

 

代码如下：

 

package threadSync;
import java.util.LinkedList;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  
/**
 * 仓库类Storage的父类，做接口用，其子类必须重载这两个方法
 * 
 */
 class SupperStorage {
 public void produce(int num){
 System.out.println("SupperStorage::produce()");
 };
 public void consume(int num){
  System.out.println("SupperStorage::consume()"); 
 };
 
}
 /**
  * 仓库类Storage3实现缓冲区  with LinkedBlockingQueue
  * 
  */
  class Storage3 extends SupperStorage
 {
  // 仓库最大存储量
  private final int MAX_SIZE = 200;
  // 仓库存储的载体
  private LinkedBlockingQueue<Object>list=new LinkedBlockingQueue<Object>(MAX_SIZE);
  // 生产num个产品
  public void produce(int num)
  {
   // 如果仓库 is full
   if (list.size() == MAX_SIZE)
   {
    System.out.println("【库存量】 is full: " + MAX_SIZE + " 暂时不能执行生产任务!");
   }
   // 生产条件满足情况下，生产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("【库存量】 is empty, 暂时不能执行消费任务!");
   }
   // 消费条件满足情况下，消费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;
  }
 }
  
 /**
  * 仓库类Storage2实现缓冲区 with await() / signal()
  * 
  */
 class Storage2 extends SupperStorage
 {
  // 仓库最大存储量
  private final int MAX_SIZE = 200;
  // 仓库存储的载体
  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 + " 【库存量】:" + list.size()
            + " 暂时不能执行生产任务!");
    try
    {
     // 由于条件不满足，生产阻塞
     System.out.println(Thread.currentThread().getName()+" enter await");
     full.await();
    }
    catch (InterruptedException e)
    {
     e.printStackTrace();
    }
   }
   // 生产条件满足情况下，生产num个产品
   for (int i = 1; i <= num; ++i)
   {
    list.add(new Object());
   }
   System.out.println(Thread.currentThread().getName() + " 【已经生产产品数】:" + num + " 【现仓储量为】:" + list.size());
   // 唤醒其他所有线程
   full.signalAll();
   empty.signalAll();
   // 释放锁
   lock.unlock();
  }
  // 消费num个产品
  public void consume(int num)
  {
   // 获得锁
   lock.lock();
   // 如果仓库存储量不足
   while (list.size() < num)
   {
    System.out.println( Thread.currentThread().getName() + "【要消费的产品数量】: " + num + " 【库存量】:" + list.size()
            + " 暂时不能执行消费任务!");
    try
    {
     // 由于条件不满足，消费阻塞
     System.out.println(Thread.currentThread().getName()+" enter await");
     empty.await();
    }
    catch (InterruptedException e)
    {
     e.printStackTrace();
    }
   }
   // 消费条件满足情况下，消费num个产品
   for (int i = 1; i <= num; ++i)
   {
    list.remove();
   }
   System.out.println(Thread.currentThread().getName() + " 【已经消费产品数】: " + num + " 【现仓储量为】:" + 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;
  }
 }
 
 // Storage with wait() / notify()
 
 class Storage extends SupperStorage {
 // 仓库最大存储量
 private final int MAX_SIZE = 200;
 // 仓库存储的载体
 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 
   *  
  */  
 class Producer extends Thread  
 {  
     // 每次生产的产品数量   
     private int num;  
   
     // 所在放置的仓库   
     private SupperStorage storage;  
   
     // 构造函数，设置仓库   
     public Producer(SupperStorage 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 SupperStorage getStorage()  
     {  
         return storage;  
     }  
   
     public void setStorage(SupperStorage storage)  
     {  
         this.storage = storage;  
     }  
 }  
 class Producer2 implements Runnable  
 {  
     // 每次生产的产品数量   
     private int num;  
   
     // 所在放置的仓库   
     private SupperStorage storage;  
   
     // 构造函数，设置仓库   
     public Producer2(SupperStorage 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 SupperStorage getStorage()  
     {  
         return storage;  
     }  
   
     public void setStorage(SupperStorage storage)  
     {  
         this.storage = storage;  
     }  
 }  
 class Consumer extends Thread
{
 // 每次消费的产品数量
 private int num;
 // 所在放置的仓库
 private SupperStorage storage;
 // 构造函数，设置仓库
 public Consumer(SupperStorage 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 SupperStorage getStorage()
 {
  return storage;
 }
 public void setStorage(SupperStorage storage)
 {
  this.storage = storage;
 }
}
 
 class Consumer2 implements Runnable
 {
  // 每次消费的产品数量
  private int num;
  // 所在放置的仓库
  private SupperStorage storage;
  // 构造函数，设置仓库
  public Consumer2 (SupperStorage 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 SupperStorage getStorage()
  {
   return storage;
  }
  public void setStorage(SupperStorage storage)
  {
   this.storage = storage;
  }
 }
/**
 * 测试类Test
 * 
 */
public class mythreadsync
{
 //this method is used to test thread generated via class Thread 
 public void test_thread() {
   
  System.out.println("test_thread(): enter");
   //SupperStorage storage = new Storage3();
   //SupperStorage storage = new Storage();
   SupperStorage storage = new Storage2();
   // 生产者对象
   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();
   System.out.println("test_thread(): exit");
 }
 
 //this method is used to test threads implementing interface runnable
 
 public void test_thread_runnable() {
  
  System.out.println("test_thread_runnable(): enter");
  SupperStorage storage = new Storage2();
  // 生产者对象
  
  Producer2 p1 = new Producer2(storage);
  Producer2 p2 = new Producer2(storage);
  Producer2 p3 = new Producer2(storage);
  Producer2 p4 = new Producer2(storage);
  Producer2 p5 = new Producer2(storage);
  Producer2 p6 = new Producer2(storage);
  Producer2 p7 = new Producer2(storage);
  // 消费者对象
  Consumer2 c1 = new Consumer2(storage);
  Consumer2 c2 = new Consumer2(storage);
  Consumer2 c3 = new Consumer2(storage);
  // 设置生产者产品生产数量
  p1.setNum(10);
  p2.setNum(10);
  p3.setNum(10);
  p4.setNum(10);
  p5.setNum(10);
  p6.setNum(20);
  p7.setNum(80);
  // 设置消费者产品消费数量
  c1.setNum(50);
  c2.setNum(20);
  c3.setNum(30);
  // 线程开始执行
  new Thread(c1,"consumer 1").start();
  new Thread(c2,"consumer 2").start();
  new Thread(c3,"consumer 3").start();
  
  new Thread(p1,"producer 1").start();
  new Thread(p2,"producer 2").start();
  new Thread(p3,"producer 3").start();
  new Thread(p4,"producer 4").start();
  new Thread(p5,"producer 5").start();
  new Thread(p6,"producer 6").start();
  new Thread(p7,"producer 7").start();
  System.out.println("test_thread_runnable(): exit");
    }
 
 //this method is used to test threads pool for thread implementing interface runnable
 
  public void test_threadpool_runnal() {
   
   System.out.println("test_threadpool_runnal(): enter");
   SupperStorage storage = new Storage2();
   
   // 生产者对象
   Producer2 p1 = new Producer2(storage);
   Producer2 p2 = new Producer2(storage);
   Producer2 p3 = new Producer2(storage);
   Producer2 p4 = new Producer2(storage);
   Producer2 p5 = new Producer2(storage);
   Producer2 p6 = new Producer2(storage);
   Producer2 p7 = new Producer2(storage);
   // 消费者对象
   Consumer2 c1 = new Consumer2(storage);
   Consumer2 c2 = new Consumer2(storage);
   Consumer2 c3 = new Consumer2(storage);
   // 设置生产者产品生产数量
   p1.setNum(10);
   p2.setNum(20);
   p3.setNum(30);
   p4.setNum(40);
   p5.setNum(50);
   p6.setNum(60);
   p7.setNum(70);
   // 设置消费者产品消费数量
   c1.setNum(30);
   c2.setNum(50);
   c3.setNum(80);
   
   ExecutorService pool=Executors.newFixedThreadPool(5);//创建一个固定大小为5的线程池  
   // 线程开始执行
   // 3 consumers
   pool.submit(c1);
   pool.submit(c2);
   pool.submit(c3);
   
   // 7 producers
   pool.submit(p1);
   pool.submit(p2);
   pool.submit(p3);
   pool.submit(p4);
   pool.submit(p5);
   pool.submit(p6);
   pool.submit(p7);
/*
 * it shows, at most, only 5 working threads in parallel even if 10 tasks submitted.
 * 
test_threadpool_runnal(): enter
pool-1-thread-1【要消费的产品数量】: 30 【库存量】:0 暂时不能执行消费任务!
pool-1-thread-1 enter await
pool-1-thread-2【要消费的产品数量】: 50 【库存量】:0 暂时不能执行消费任务!
pool-1-thread-2 enter await
pool-1-thread-4 【已经生产产品数】:10 【现仓储量为】:10
test_threadpool_runnal(): exit
pool-1-thread-5 【已经生产产品数】:20 【现仓储量为】:30
pool-1-thread-3【要消费的产品数量】: 80 【库存量】:30 暂时不能执行消费任务!
pool-1-thread-3 enter await
pool-1-thread-1 【已经消费产品数】: 30 【现仓储量为】:0
pool-1-thread-1 【已经生产产品数】:50 【现仓储量为】:50
pool-1-thread-1 【已经生产产品数】:60 【现仓储量为】:110
pool-1-thread-1 【已经生产产品数】:70 【现仓储量为】:180
pool-1-thread-2 【已经消费产品数】: 50 【现仓储量为】:130
pool-1-thread-4 【已经生产产品数】:30 【现仓储量为】:160
pool-1-thread-5 【已经生产产品数】:40 【现仓储量为】:200
pool-1-thread-3 【已经消费产品数】: 80 【现仓储量为】:120
 */
   pool.shutdown();
   System.out.println("test_threadpool_runnal(): exit");
     }
  
 public static void main(String[] args) {
  mythreadsync my = new mythreadsync();
  //my.test_thread();
  my.test_threadpool_runnal();
  //my.test_thread_runnable();
  
 }
}
大树叶
关注
专栏目录
编程实现生产者消费者或读写者的同步问题
04-21
设计在同一个进程地址空间内执行的多个线程。生产者线程和消费者线程。生产者线程生产物品，然后将物品放置在一个空缓冲区中供消费者线程消费。消费者线程从缓冲区中获得物品，然后释放缓冲区。生产者线程生产物品时，若无空缓冲区可用，生产者线程必须等待消费者线程释放出一个空缓冲区；消费者线程消费物品时，若无满的缓冲区，消费者线程将被阻塞，直到新的物品被生产出来。
生产者消费者问题理解与Java实现
weixin_33968104的博客
02-25 144
生产者消费者问题（英语：Producer-consumer problem），也称有限缓冲问题（英语：Bounded-buffer problem），是一个多线程同步问题的经典案例。该问题描述了两个共享固定大小缓冲区的线程——即所谓的“生产者”和“消费者”——在实际运行时会发生的问题。生产者的主要作用是生成一定量的数据放到缓冲区中，然后重复此过程。与此同时，消费者也在缓冲区消耗这些数据。该问题的关...
Java线程同步：生产者-消费者 模型（代码示例）
Zhang Phil
02-13 1982
public class ThreadSyn { public static void main(String[] args) { new ThreadSyn(); } public ThreadSyn() { Queue queue = new Queue(); Producter p = new Producter(queue); Consumer c = new
生产者消费者问题（java实现）
leozston的专栏
12-05 645
1、生产者、消费者模型（若容器容量为1） 生产者线程： if(a ==1) { wait() } a++; notify; 消费者： if (a == 0) { wait(); } a--; notify; 2、下面是一个代码实现（简单的缓存容量只有1，即：若容器中有一个了，就不能再生产了）： （1）最基本的写法： 资源类：（资源类或者共享对象
进程同步实验——生产者与消费者问题算法实现
12-11
进程同步实验——生产者与消费者问题算法实现
Java 生产者/消费者问题实例详解
08-30
Java中的生产者/消费者问题是一种典型的多线程同步问题，涉及到资源的共享和协作。在该问题中，生产者线程负责生成数据并放入共享存储区（如缓冲区），而消费者线程则负责从存储区取出数据进行处理。如果不进行有效...
JAVA多线程实现生产者消费者的实例详解
08-30
JAVA多线程实现生产者消费者是指在JAVA编程语言中使用多线程技术来实现生产者消费者模型的实例详解。生产者消费者模型是指在计算机科学中的一种经典模式，描述了生产者和消费者之间的协作关系。在这个模型中，生产者...
Java实现简易生产者消费者模型过程解析
08-19
二、Java实现生产者消费者模型 在Java中，生产者消费者模型可以通过使用同步机制和wait/notify机制来实现。在下面的示例代码中，我们将创建四个类：生产者类、产品类、消费者类和测试类。 生产者类 生产者类负责...
java解决单缓冲生产者消费者问题示例
09-04
总之，Java中的这个单缓冲生产者消费者问题示例展示了如何使用线程同步原语（如锁和条件变量）来解决多线程环境下的数据共享问题，为实际的并发编程提供了基础的解决方案。开发者可以根据需求调整线程数量、生产/...
Java实现生产者消费者问题与读者写者问题详解
08-28
Java实现生产者消费者问题与读者写者问题详解 Java语言在多线程编程中提供了对同步机制的良好支持，解决生产者/消费者问题的方法可分为两类：（1）采用某种机制保护生产者和消费者之间的同步；（2）在生产者和消费...
Dubbo生产者消费者示例源代码（基于Eclipse的Maven项目）
11-09
Dubbo生产者消费者示例源代码，Eclipse项目，基于Maven构建，可以直接导入Eclipse开发环境，本人亲测，编译通过，可以直接在Eclipse中运行（包含Main方法），先运行提供者，再运行生产者。
操作系统：多线程处理生产者消费者，java实现
04-30
基本满足操作系统课上要求，java实现的生产者消费者模型。
Java实现的生产者与消费者问题
06-12
要求:设计一个程序,由一个父进程创建三个子进程,三个子进程一个 是生产者进程, 两个是消费者进行, 父子进程都使用父进程创建的共享存储区进  行通信， 由生产者进程将一个数组中的十个数值发送到由 5 个缓冲区组成的共享 内存中，两个消费者进程轮流接收并输出这十个数值，同时将两个消费者进程读 出的数值进行累加求和
java生产者消费者问题实现
Android进阶三部曲 - 刘望舒
08-07 1791
/**   *经典生产者与消费者问题：生产者不断的往仓库中存放产品，消费者从仓库中消费产品。   *其中生产者和消费者都可以有若干个。仓库容量有限，库满时不能存放，库空时不能取产品    */      public class ProducersAndConsumers {       public static void main(String[] args) {
生产者消费者模式演示代码
m0_37952284的博客
06-19 669
package com.test;import java.util.LinkedList;public class ProductorConsumerDemo { public static void main(String[] args) { Basket basket =new Basket(); Productor pro=new Productor(basket); Consumer...
java多线程学习--生产者消费者问题
fly_fly_fly_pig的博客
07-19 286
生产者消费者问题是一个经典的同步问题,曾经在操作系统中接触过,还有哲学家就餐问题. 今天在学习多线程时,又遇到这个例子,今天就讨论一下生产者消费者问题的解决方法. 1.一对一 代码实现 public class Resouce { private String name; //计数器 private int count = 1; private Boole...
简单生产者-消费者
labty的博客
10-16 112
考虑一个场景：一个饭店有一个厨师和一个服务员。菜做好之后，厨师通知服务员端菜，服务员端完菜之后厨师才能做菜。 代码如下： [code="java"]public class Meal { private final int orderNum; public Meal(int orderNum) { // TODO Auto-generated constru...
java中实现生产者消费者（两种方式）
wenyuerpf的博客
11-30 170
一、wait(),notify()实现生产者消费者 import java.util.ArrayList; //测试类 public class MainMethed { public static void main(String[] args) { ProductPool pool = new ProductPool(8,new ArrayList<Product...
消费者和生产者问题（Java实现）
欧阳子遥的博客
08-23 350
消费者和生产者问题演示之吃包子demo 简单介绍 本例采用包子类BaoZi作为缓冲区，BaoZiPu为包子铺线程类，即为生产者，ChiHuo为吃货线程类，即为消费者。 吃包子问题逻辑分析 顾客来包子铺买包子，说“老板，来二两包子。”（程序开始，包子类即缓冲区为空，have为false），于是顾客开始打盹。（起得早没睡醒，此为消费者阻塞 bz.wait()） 老板：“好的，客官请稍等，马上来。”（经判断，没有包子即have为false，消费者唤醒生产者，让老板做2秒，即Thread.sleep(2000)，
Java多线程生产者消费者问题实现与示例
在JAVA作业二——生产者消费者问题中，学生们被要求实现一个多线程环境下的生产者-消费者模型。该模型的关键在于设计两个独立的线程，生产者负责生产数据（商品），而消费者负责消费这些数据。以下是核心知识点的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值