生产者消费者解读

最新推荐文章于 2023-01-18 14:59:00 发布
最新推荐文章于 2023-01-18 14:59:00 发布
阅读量363 收藏
点赞数
分类专栏： 大数据，多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_31780525/article/details/54848085
版权

1、jdk1.5前实现一个简单的生产者消费者模型

一把锁  多个生产者多个消费者  -- 实现生产一个消费一个

class Product3
{
   private String name;
   private int count;
   private boolean flag;

   //生产产品的功能
   public synchronized void produce(String name)
    {
        while(flag)
        {          
            try{wait();}catch(InterruptedException e){e.printStackTrace();}
        }
        this.name = name+"..."+count;
        System.out.println(Thread.currentThread().getName()+"生产了....."+this.name);
        count++;
        flag = true;
        notifyAll();
    }
  //消费产品的功能
  public synchronized void consume()
    {
        while(!flag)
        {
            try{wait();}catch(InterruptedException e){e.printStackTrace();}
        }
        System.out.println(Thread.currentThread().getName()+"......消费了....."+name);
        flag = false;
        notifyAll();
    }
}


//生产任务
class Producer3 implements Runnable
{
    private Product3 pro;
    public Producer3(Product3 pro)
    {
        this.pro =pro;
    }
    public void run()
    {
        while(true)
        {
            pro.produce("笔记本");
        }
    }
}
//消费任务
class Consumer3 implements Runnable
{ 
    private Product3 pro;
    public Consumer3(Product3 pro)
    {
        this.pro =pro;
    }
    public void run()
    {
        while(true)
        {
            pro.consume();
        }
    }
}
class Demo1
{
    public static void main(String[] args) 
    {
        Product3 pro = new Product3();

        Producer3 Producer3 =new Producer3(pro);
        Consumer3 Consumer3 = new Consumer3(pro);

        Thread t0 = new Thread(Producer3);
        Thread t1 = new Thread(Producer3);

        Thread t2 =  new Thread(Consumer3);
        Thread t3 =  new Thread(Consumer3);

        t0.start();
        t1.start();

        t2.start();
        t3.start();


    }
}
2、jdk1.5后实现一个简单的生产者消费者模型
一把锁  多个生产者多个消费者  -- 实现生产一个消费一个 

import java.util.concurrent.locks.*;
class Product0
{
   private String name;
   private int count;
   private boolean flag;

   //创建一把锁
   private Lock lock = new ReentrantLock();

   //得到和锁绑定的Condition对象
   private Condition con = lock.newCondition();

   //生产产品的功能
   public  void produce(String name)
	{
	    lock.lock();//获取锁
	   try{
			while(flag)
			{     
				try{con.await();}catch(InterruptedException e){e.printStackTrace();}
			}
			this.name = name+"..."+count;
			System.out.println(Thread.currentThread().getName()+"生产了....."+this.name);
			count++;
			flag = true;
			con.signalAll();
	    }
		finally
		{
			lock.unlock();//释放锁
		}
    }
  //消费产品的功能
  public void consume()
	{
	    lock.lock();
		try{
			while(!flag)
			{
				try{con.await();}catch(InterruptedException e){e.printStackTrace();}
			}
			System.out.println(Thread.currentThread().getName()+"......消费了....."+name);
			flag = false;
			con.signalAll();
		}
		finally
		{
			lock.unlock();
		}
    }
}

//生产任务
class Producer0 implements Runnable
{
    private Product0 pro;
	public Producer0(Product0 pro)
	{
		this.pro =pro;
	}
	public void run()
	{
		while(true)
		{
			pro.produce("笔记本");
		}
	}
}
//消费任务
class Consumer0 implements Runnable
{ 
    private Product0 pro;
	public Consumer0(Product0 pro)
	{
		this.pro =pro;
	}
	public void run()
	{
		while(true)
		{
			pro.consume();
		}
	}
}
class Demo2
{
	public static void main(String[] args) 
	{
		Product0 pro = new Product0();

		Producer0 Producer0 =new Producer0(pro);
		Consumer0 Consumer0 = new Consumer0(pro);

		Thread t0 = new Thread(Producer0);
		Thread t1 = new Thread(Producer0);

		Thread t2 =  new Thread(Consumer0);
		Thread t3 =  new Thread(Consumer0);

		t0.start();
		t1.start();

		t2.start();
		t3.start();
	}
}
3、用两把锁对代码进行优化

一把锁  多个生产者多个消费者  -- 实现生产一个消费一个

import java.util.concurrent.locks.*;
class Product
{
   private String name;
   private int count;
   private boolean flag;

   //创建一把锁
   private Lock lock = new ReentrantLock();

   //得到和锁绑定的Condition对象，控制生产线程的唤醒和等待
   private Condition pro = lock.newCondition();

   //得到和锁绑定的Condition对象，控制消费线程的唤醒和等待
   private Condition con = lock.newCondition();

   //生产产品的功能  为false生产   为true消费 
   public  void produce(String name)
	{
	    lock.lock();//获取锁
	   try{
			while(flag)
			{     
				try{pro.await();}catch(InterruptedException e){e.printStackTrace();}
			}
			this.name = name+"..."+count;  //this用到比较棒
			System.out.println(Thread.currentThread().getName()+"生产了....."+this.name);
			count++;
			flag = true;
			con.signal();
	    }
		finally
		{
			lock.unlock();//释放锁
		}
    }
  //消费产品的功能
  public void consume()
	{
	    lock.lock();
		try{
			while(!flag)
			{
				try{con.await();}catch(InterruptedException e){e.printStackTrace();}
			}
			System.out.println(Thread.currentThread().getName()+"......消费了....."+name);
			flag = false;
			pro.signal();
		}
		finally
		{
			lock.unlock();
		}
    }
}


//生产任务
class Producer implements Runnable
{
    private Product pro;
	public Producer(Product pro)
	{
		this.pro =pro;
	}
	public void run()
	{
		while(true)
		{
			pro.produce("笔记本");
		}
	}
}
//消费任务
class Consumer implements Runnable
{ 
    private Product pro;
	public Consumer(Product pro)
	{
		this.pro =pro;
	}
	public void run()
	{
		while(true)
		{
			pro.consume();
		}
	}
}
class Demo3
{
	public static void main(String[] args) 
	{
		Product pro = new Product();

		Producer producer =new Producer(pro);
		Consumer consumer = new Consumer(pro);

		Thread t0 = new Thread(producer);
		Thread t1 = new Thread(producer);

		Thread t2 =  new Thread(consumer);
		Thread t3 =  new Thread(consumer);

		t0.start();
		t1.start();

		t2.start();
		t3.start();
	}
}

结果示例：

Thread-0生产了.....笔记本...105756
Thread-3......消费了.....笔记本...105756
Thread-1生产了.....笔记本...105757
Thread-2......消费了.....笔记本...105757
Thread-0生产了.....笔记本...105758
Thread-3......消费了.....笔记本...105758
Thread-1生产了.....笔记本...105759
Thread-2......消费了.....笔记本...105759
Thread-0生产了.....笔记本...105760
Thread-3......消费了.....笔记本...105760


4、最多生产N个产品, 
class Product2
{
	//产品名称
    private String name;
	//产品价格
	private double price;
	//存放产品的容器
	private Product2[] arr = new Product2[100];
	//创建一把锁
	private Lock lock =new ReentrantLock();
	//创建和锁绑定的Condition对象，控制生产线程
	private Condition pro = lock.newCondition();
	//创建和锁绑定的Condition对象，控制消费线程
	private Condition con = lock.newCondition();
	//生产使用的下标
	private int propointer;
	//消费使用的下标
	private int conpointer;
	//记录产品数量
	private int count;

	public Product2(){}
	public Product2(String name,double price)
	{
		this.name = name;
		this.price = price;
	}
	//生产功能
	public void produce()
	{
		lock.lock();
		try
		{
			//先判断该不该生产，当容器满的时候不能生产
			while(count==arr.length)
			{
				try{pro.await();}catch(InterruptedException e){e.printStackTrace();}
			}
			arr[propointer]=new Product2("衬衣",99.99);
            System.out.println(Thread.currentThread().getName()+"...生产了"+arr[propointer]+"..."+count);
			count++;//数量加1
			if(++propointer==arr.length)
				propointer=0;
			con.signal();
		}
		finally
		{
			lock.unlock();
		}
	}
	//消费功能
	public void consume()
	{
		lock.lock();
		try
		{
			//先判断该不该消费，当商品数量为0 的时候，不能消费
			while(count==0)
			{
				try{con.await();}catch(InterruptedException e){e.printStackTrace();}
			}
			Product2 yifu = arr[conpointer];
			System.out.println(Thread.currentThread().getName()+"...消费了"+yifu);
            count--;
            if(++conpointer==arr.length)
				conpointer=0;
            pro.signal();
		}
		finally
		{
			lock.unlock();
		}
	}

	public String toString()  //打印的是对象，要重写toString方法
	{
		return name+","+price;
	}

}
class Producer2 implements Runnable
{
	private Product2 clo;
	public Producer2(Product2 clo)
	{
		this.clo = clo;
	}
	public void run()
	{
	    while(true)
		{
			clo.produce();
		}
	}
}
class Consumer2 implements Runnable
{
	private Product2 clo;
	public Consumer2(Product2 clo)
	{
		this.clo = clo;
	}
	public void run()
	{
		while(true)
		{
			clo.consume();
		}
	}
}
class Demo4
{
	public static void main(String[] args) 
	{
		Product2 clo = new Product2();

		Producer2 Producer2 = new Producer2(clo);

		Consumer2 Consumer2 = new Consumer2(clo);

		Thread t1 = new Thread(Producer2,"生产者1");
		Thread t2 = new Thread(Producer2,"生产者2");

		Thread t3 = new Thread(Consumer2,"消费1");
		Thread t4 = new Thread(Consumer2,"消费2");

		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}
}
结果示例： 
生产者1...生产了衬衣,99.99...93
生产者1...生产了衬衣,99.99...94
生产者1...生产了衬衣,99.99...95
生产者1...生产了衬衣,99.99...96
生产者1...生产了衬衣,99.99...97
生产者1...生产了衬衣,99.99...98
生产者1...生产了衬衣,99.99...99
消费1...消费了衬衣,99.99
消费1...消费了衬衣,99.99
消费1...消费了衬衣,99.99
消费1...消费了衬衣,99.99

龙骨
关注
专栏目录
生产者与消费者分析
yiyongjiajun521的博客
08-04 2172
众所周知大型网站都是并发支持，用到最多的也是生产者与消费者模式。 生产消费者模型 　　　　生产者消费者模型具体来讲，就是在一个系统中，存在生产者和消费者两种角色，他们通过内存缓冲区进行通信，生产者生产消费者需要的资料，消费者把资料做成产品。 ，譬如注册用户这种服务，它可能解耦成好几种独立的服务（账号验证，邮箱验证码，手机短信码等）。它们作为消费者，等待用户输入数据，在前台数据提交之后会经过...
c++生产者与消费者
05-05
在深入探讨C++中的“生产者与消费者”模式之前，我们先来理解这一经典问题的背景及其在操作系统和多线程编程中的应用。生产者与消费者问题是计算机科学中用于研究同步问题的一个著名模型，最早由荷兰计算机科学家...
生产者 消费者 进程 可视化 java
11-15
以车库为例子，一组生产者向一组消费者提供消息，它们共享一个有界缓冲池，生产者向其中投放消息，消费者从中取得消息。 根据进程同步机制，编写一个解决上述问题的可视化程序，可显示缓冲池状态、放数据、取数据等过程。
生产者消费者模式详解
周将的博客
03-24 780
实现生产消费者模式的几种方式
简析生产者消费者模式及代码实现
weixin_43825537的博客
03-13 266
生产者消费者模式 概念 生产者/消费者模型描述的是有一块缓冲区作为仓库，生产者可将产品放入仓库，消费者可以从仓库中取出产品， 生产者/消费者模型关注的是以下几点： 1）生产者生产的时候消费者不能消费 2）消费者消费的时候生产者不能生产 3）缓冲区空的时候消费者不能消费 4）缓冲区满的时候生产者不能生产 代码实现 下面我使用线程同步的原语条件变量和互斥锁来实现生产者消费者模式，用链...
生产者消费者模型分析与实现
如何心安理得的在老板眼皮下摸鱼
03-06 225
生产者消费者模式就是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。这个阻塞队列就是用来给生产者和消费者解耦的。 首先定义BlockingQueue类，这个类就相当于仓库，用队列来存储数据。 //存取数据 private final LinkedL..
生产者和消费者.zip
08-18
**描述解读：** 提供的压缩包包含了"生产者消费者实验报告.doc"，这意味着学习者可以找到一份详细的实践报告，这可能包含了理论分析、实验步骤、结果讨论以及可能遇到的问题及其解决方案。这份报告有助于理解和应用...
生产者与消费者问题算法实现.txt
05-26
### 生产者与消费者问题算法实现 #### 一、引言 在计算机科学领域中，“生产者-消费者问题”（Producer-Consumer Problem）是多线程编程中的一个经典问题，通常用于解决进程间的同步问题。该问题的核心在于如何...
操作系统课程设计 生产者消费者问题
12-29
根据提供的文件信息，我们可以归纳出以下关键知识点，这些知识点主要围绕“生产者消费者问题”在操作系统课程设计中的实现展开。 ### 1. 生产者消费者问题概述 生产者消费者问题是一个经典的多线程同步问题，它被...
生产者消费者算法图形化演示系统
02-24
对操作系统中的生产者消费者算法进行模拟，是大家能用更容易的理解该算法。采用了MFC和多线程机制，有兴趣的可以看看
生产者和消费者问题（操作系统中的经典问题）
05-11
进程中创建多个线程模拟生产者和消费者，并且满足以下要求：生产者可以把产品放到任意缓冲区中，消费者只消费指定生产者的产品，且为各生产者分配缓冲区时，各生产者必须互斥，各生产者的具体活动并发，而消费者只有在对同一产品进行消费时才互斥。
生产者消费者 多线程
09-22
生产者消费者 多线程
经典的生产者消费者模型Java实现结果分析
最新发布
预见未来to50的专栏
01-18 951
经典的生产者消费者模型： 生产者不断的往仓库中存放产品，消费者从仓库中消费产品。 其中生产者和消费者都可以有若干个。 仓库规则：容量有限，库满时不能存放，库空时不能取产品 。本实现中，有2个生产者P1和P2，3个消费者C1, C2和C3，仓库容量10。运行结果分析：Seq.Activity DescriptionProductIDC1C2C3P1P2ProduceConsumeStorage1consumer waitNNNNNNN2consumer waitNNNNNNN3consumer waitNN
生产者消费者的实现与思考
潜心种树
12-04 5388
生产者消费者的Java实现生产者：负责生产消息，在缓冲区满后休眠； 消费者：负责消费消息，在缓冲区空后休眠；两者的休眠何时唤醒？1.生产者休眠，是因为缓冲区满，所以只要消费者进行了消费，那么缓冲区就会有新的空间，生产者就可以继续生产，故每次消费者消费以后都要试图唤醒生产者，无论生产者是否休眠。2.消费者休眠，是因为缓冲区空，所以只要生产者进行了生成，那么缓冲区就会有新的消息，消费者就可以继续生产，
生产者消费者模型(Qt实现)
qq_45830912的博客
05-19 2438
//mainwindow.h #ifndef MAINWINDOW_H #define MAINWINDOW_H #include <QMainWindow> #include<QObject> #include<windows.h> #include <QtCore/QCoreApplication> #include <QSemaphore> #include <QThread> #include <QMutex>.
轻量级的进程内生产者/消费者实现
terry2870的专栏
03-23 301
文章目录前言一、优缺点1、优点2、缺点二、代码实现1.工厂类2.消费者抽象类3.生产者4.使用示例5.队列监控 前言     在我们项目中在处理一些耗时比较长，而且不太关心处理结果的任务时，我们经常会使用到消息中间件。我们把任务扔进消息队列里，然后由消费者慢慢的处理一条一条的任务。我们最常见的消息中间件有：activeMQ，rabbitMQ，kafka等等。     上面的这些消息中间件都是比较典型的生产者/消费者模型，在项目中根据自己业务规模和能力选择不同的中间件来处理。     这里我给大家介绍一个利
操作系统 —— 生产者消费者问题JAVA代码实现 [有比较low的界面]
qq_45770364的博客
04-08 1880
生产者消费者问题JAVA代码说明文档 一、生产者消费者问题说明 ​ 生产者消费者问题（英语：Producer-consumer problem），也称有限缓冲问题（英语：Bounded-buffer problem），是一个多线程同步问题的经典案例。该问题描述了两个共享固定大小缓冲的线程——即所谓的“生产者”和“消费者”——在实际运行时会发生的问题。生产者的主要作用是生成一定量的数据放到缓冲区中，然后重复此过程。与此同时，消费者也在缓冲区消耗这些数据。该问题的关键就是要保证生产者不会在缓冲区满时加入数据，
多进程生产者消费者框架设计
神技圈子的博客
04-24 2764
前言 介绍了进程如何基于面向对象的封装，本章我们基于封装好的Process类来实现一种无锁版的生产者和消费者框架，用它实现了高性能文件拷贝功能。读这篇文章之前大家可以想一下如果是你，你会怎么设计这样的框架？在这个模型中作为每个生产者，如何把读取到内容发送给消费者。而作为消费者，如何把接收到的内容写入文件，并且最终保证文件内容是一致的。 好了，废话不多说，我们来通过代码看下是怎么设计的吧？ 生产者消费者模型 我们回顾一下什么是生产者消费者模型。这个模型是为了解决在整个程序过程中既要不断产生数据，又要处理数据的
华东交大操作系统课程设计：生产者-消费者问题模拟实现
"该资源是华东交通大学软件学院的一份关于操作系统课程设计的文档，主要针对生产者消费者问题的模拟实现。这份设计任务书详细规定了课程设计的目标、内容、要求、评分标准以及进度安排，旨在让学生掌握网站压力测试...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值