生产者和消费者问题

最新推荐文章于 2024-09-29 08:33:21 发布
最新推荐文章于 2024-09-29 08:33:21 发布
阅读量142 收藏
点赞数
文章标签： java 多线程 thread
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/serendipity_xr/article/details/113807834
版权

生产者和消费者问题

  • 要想买一辆汽车，先生产一台汽车。做一台卖一台 ，没有的话就生产 有的话不生产光卖。

一.基本做法(不加锁和加锁)

1.不加锁

  • Car.java
public class Car {
	private String name;
	private String color;

	public Car() {
		super();
		// TODO Auto-generated constructor stub
	}

	public Car(String name, String color) {
		super();
		this.name = name;
		this.color = color;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getColor() {
		return color;
	}

	public void setColor(String color) {
		this.color = color;
	}

	// 生产汽车的方法
	public void prodCar(String name, String color) {
		//给对象赋值
		this.name=name;
		this.color=color;
		}


	// 销售汽车的方法
	public void sellCar() {
		System.out.println("汽车的名字是"+name+"汽车的颜色"+color);
		}
}
  • Customer.java
public class Customer implements Runnable{
	//引入Car
	Car car;
	
	public Customer(Car car) {
		super();
		this.car = car;
	}

	public Customer() {
		super();
		// TODO Auto-generated constructor stub
	}
	//消费汽车
	int count=1;
	@Override
	public void run() {
		// TODO Auto-generated method stub
		while(count<=100) {
			count++;
			car.sellCar();
			//休眠一下
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}

}
  • Producer.java
public class Producer implements Runnable {
	// 引用Car
	Car car;

	public Producer(Car car) {
		super();
		this.car = car;
	}

	public Producer() {
		super();
		// TODO Auto-generated constructor stub
	}

	int count = 1;
	//实际生产汽车的方法
	@Override
	public void run() {
		// TODO Auto-generated method stub
		while (count <= 100) {
			count++;
			int num = new Random().nextInt(2);
			if (num % 2 == 0) {
				car.prodCar("奥迪", "黑色");
			} else {
				car.prodCar("宝马", "红色");
			}
			//休眠一下
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}

}
  • 主程序Test
public class Test {
	public static void main(String[] args) {
		//实例化Car
		Car car=new Car();
		//实例化runnable接口
		Producer pd=new Producer(car);
		Customer ct=new Customer(car);
		//创建thread线程
		Thread pt=new Thread(pd);
		Thread tc=new Thread(ct);
		//启动线程
		pt.start();
		tc.start();
		
	}
}

出现的问题

  • 消费者和生产者数据不统一 ；
  • 没有生产就开始销售，导致消费的数据为null；
  • 生产的对象的信息与消费到的信息不统一：奥迪—红色，null—黑色，宝马—黑色 ；

2.使用lock锁

  • 给操作加上锁，使用重入锁或者synchrozed ；
  • 在生产者和消费者对象中，run里面加入lock锁 ，避免数据不一致 ；
  • 生产一次消费多次或没有生产就消费了，但是同一car对象的数据是一致的。
    在这里插入图片描述
  • Car.java
public class Car {
	private String name;
	private String color;

	public Car() {
		super();
		// TODO Auto-generated constructor stub
	}

	public Car(String name, String color) {
		super();
		this.name = name;
		this.color = color;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getColor() {
		return color;
	}

	public void setColor(String color) {
		this.color = color;
	}

	// 生产汽车的方法
	public void prodCar(String name, String color) {
		//给对象赋值
		this.name=name;
		this.color=color;
		}
	
	

	

	// 销售汽车的方法
	public void sellCar() {
		System.out.println("汽车的名字是"+name+"汽车的颜色"+color);
		}
}
  • Customer.java
public class Customer implements Runnable{
	//引入Car
	Car car;
	
	public Customer(Car car) {
		super();
		this.car = car;
	}

	public Customer() {
		super();
		// TODO Auto-generated constructor stub
	}
	//消费汽车
	int count=1;
	//创建锁
	ReentrantLock lock=new ReentrantLock();
	@Override
	public void run() {
		// TODO Auto-generated method stub
		while(count<=100) {
			//加锁
			lock.lock();
			count++;
			car.sellCar();
			//休眠一下
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		//释放锁
		lock.unlock();
	}

}
  • Producer.java
public class Producer implements Runnable {
	// 引用Car
	Car car;

	public Producer(Car car) {
		super();
		this.car = car;
	}

	public Producer() {
		super();
		// TODO Auto-generated constructor stub
	}

	int count = 1;
	//创建锁
	ReentrantLock lock=new ReentrantLock();
	//实际生产汽车的方法
	@Override
	public void run() {
		// TODO Auto-generated method stub
		while (count <= 100) {
			//加锁
			lock.lock();
			count++;
			int num = new Random().nextInt(2);
			if (num % 2 == 0) {
				car.prodCar("奥迪", "黑色");
			} else {
				car.prodCar("宝马", "红色");
			}
			//休眠一下
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			//解锁
			lock.unlock();
		}
	}

}
  • Test.java
public class Test {
	public static void main(String[] args) {
		//实例化Car
		Car car=new Car();
		//实例化runnable接口
		Producer pd=new Producer(car);
		Customer ct=new Customer(car);
		//创建thread线程
		Thread pt=new Thread(pd);
		Thread tc=new Thread(ct);
		//启动线程
		pt.start();
		tc.start();
		
	}
}

二.使用 object的等待唤醒机制

  • 先生产后消费，程序启动之后要先进行生产操作,后面在进行消费操作 重复此种循环操作。
  • wait将当前操作进入阻塞状态;
  • notify唤醒正在阻塞中的线程.
  • Car.java
public class Car {
	private String name;
	private String color;
	public Car() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Car(String name, String color) {
		super();
		this.name = name;
		this.color = color;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getColor() {
		return color;
	}
	public void setColor(String color) {
		this.color = color;
	}
	boolean flag=true;//true表示需要生产汽车了，false表示需要销售了
	//生产汽车的方法
	public synchronized void prodCar(String name, String color) {
		if(!flag) {//不要生产
			try {
				wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		//给对象赋值
		this.name=name;
		this.color = color;
		System.out.println("生产一台汽车");
		System.out.println("==================");
		flag=false;//已经生产了汽车，需要进入等待销售操作
		notify();//唤醒之前的销售被阻塞的状态
	}
	//销售汽车的方法
	public synchronized void sellCar() {
		//程序启动之后要先生产
		if (flag) {
			try {
				wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		System.out.println("消费了一台汽车");
		System.out.println("汽车的名字是"+name+"汽车的颜色"+color);
		System.out.println("**********************");
		flag=true;//消费完了需要再次等待了
		notify();//唤醒之前等待的线程，就是生产汽车的线程
	}
	}
  • Customer.java
public class Customer implements Runnable{
	//引入Car
	Car car;
	
	public Customer(Car car) {
		super();
		this.car = car;
	}

	public Customer() {
		super();
		// TODO Auto-generated constructor stub
	}
	//消费汽车
	int count=0;
	@Override
	public void run() {
		// TODO Auto-generated method stub
		while(count<=100) {
			count++;
			car.sellCar();
		}
	}

}
  • Producer.java
public class Producer implements Runnable{
	//引用Car
	Car car;
	
	public Producer(Car car) {
		super();
		this.car = car;
	}

	public Producer() {
		super();
		// TODO Auto-generated constructor stub
	}
	int count=0;
	@Override
	public void run() {
		// TODO Auto-generated method stub
		while(count<=100) {
			count++;
			int num=new Random().nextInt(2);
			if(num%2==0) {
				car.prodCar("奥迪", "黑色");
			}else {
				car.prodCar("宝马", "红色");
			}
		}
	}
	
}
  • Test.java
public class Test {
	public static void main(String[] args) {
		//实例化Car
		Car car=new Car();
		//实例化runnable接口
		Producer pd=new Producer(car);
		Customer ct=new Customer(car);
		//创建thread线程
		Thread pt=new Thread(pd);
		Thread tc=new Thread(ct);
		//启动线程
		pt.start();
		tc.start();
		
	}
}

wait将当前线程进入阻塞状态，当遇到notify的时候，会再次唤醒wait线程。程序继续从我们的wait位置运行。

在这里插入图片描述

serendipity_xr
关注
8、生产者与消费者案例
Chocus
10-27 885
厨师制作食物，放在取餐口让服务员取走食物，两个角色最终共享的数据即是食物 首先模拟生产消费的过程，未加同步，所以会出现两方面的问题： 1、食物与对应描述混乱 2、本来应该每样菜品生成5次，取出的菜品数量对不上（桑拿滑肉片7次，锅包肉3次） package com.chocus.demo1; public class ProductCustomerDemo { public
多线程通信经典例子：生产者/消费者问题
Yellow_Star的博客
07-01 221
多线程通信一个经典例子：生产者/消费者问题 先一起来看一下题目 一个生产者（producer）生产一件产品，当产品数量超过20时将不再生产，另有一个消费者（consumer）问店员（clerk）来购买这个产品，当产品数量少于或等于时，店员将不再售卖这件产品 分析一下题目 需不需要使用多线程？需要，一条是生产者的线程，一条是消费者的线程 需不需要共享数据？需要，共享数据为店员，或者产品 共享数据的时候会不会出现线程安全问题？会，需要用synchronized或者lock来解决 需不需要线程之间进行通信？需要
生产者消费者问题
chenyx1012的博客
06-21 356
在操作系统学习过程中遇到生产者消费者问题，生产者生产商品，消费者消费商品，但常常由于两者的速度不匹配，因此常常会出现供不应求，或者商品积压的问题。 具体实例：在cpu处理数据时，需要将数据从外存调到内存，再从内存调到cpu中进行处理，cpu存储量小但是处理速度快，而外存存储量相对比较大，但是数据传输速度于cpu相比比较慢，因此会引入一个缓存，缓和两者之间的速度不匹配的情况： 在此通过多线程的方式模拟生产者消费者的问题： 首先写模拟一个仓库，生产者生产货物存放到仓库中，消费者从仓库中消费货物。 p
一篇文章，让你彻底弄懂生产者--消费者问题
weixin_34259232的博客
05-06 304
生产者-消费者模式是一个十分经典的多线程并发协作的模式，弄懂生产者-消费者问题能够让我们对并发编程的理解加深。所谓生产者-消费者问题，实际上主要是包含了两类线程，一种是生产者线程用于生产数据，另一种是消费者线程用于消费数据，为了解耦生产者和消费者的关系，通常会采用共享的数据区域，就像是一个仓库，生产者生产数据之后直接放置在共享数据区中，并不需要关心消费者的行为；而消费者只需要从共享数据区中去获取...
操作系统概念第六章 进程同步
人间烟火的博客
01-17 706
进程同步背景临界区问题Peterson算法 背景 动机：同一程序顺序执行时是正确的，但并发执行却会发生错误的结果. 共享数据的并发访问可能导致数据的不一致 维护数据的一致性需要能够保证协作进程顺序执 行的机制 并发执行的程序会出现很多问题，一个简单的例子是生产者-消费者问题。 生产者生产资源（执行count++）的同时消费者消耗（count- -），count的初值是5，理想结果是count=5，但如果同时执行两条语句，对于生产者和消费者，他们的count都是5，那么最后根据恢复的情况不同（生产者后执行
Linux操作系统实验：生产者和消费者问题
m0_52503037的博客
04-17 3619
“生产者消费者”问题是一个著名的同时性编程问题的集合。通过编写经典的“生产者消费者”问题的实验，读者可以进一步熟悉 Linux 中多线程编程，并且掌握用信号量处理线程间的同步互斥问题。
使用信号量实现有限缓冲区的生产者和消费者问题
10-22
"生产者消费者问题"和"读写者问题"是经典的并发控制问题，通过使用信号量机制可以有效地解决这些问题。下面将详细阐述这两个问题以及如何在Linux环境下用C语言实现。 首先，我们来看“生产者消费者问题”。这个问题...
生产者和消费者问题（单一生产者和单一消费者）
我要好好当个计院狗
08-22 2492
题目一：一组生产者和一组消费者进程共享一个初始为空，大小为n的缓冲区，只有缓冲区没有满的时候，生产者才能把消息放入缓冲区，否则必须等待；只有缓冲区未空时，消费者才可以从中取出消息，否则必须等待。由于缓冲区是临界资源，所必须互斥访问。 关系分析: 1.生产者和消费者对缓冲区的访问是互斥关系； 2.生产和消费者又有着同步关系，必须先生产再消费。 信号量设置： 1.设置mutex作为互斥信号量，让生产者和消费者可以互斥地访问缓冲区，且初始值为1； 2.设置信号量full来表示非空缓冲区的个数.
Linux c语言多线程实现生产者/消费者问题
03-13
以生产者/消费者问题为例来阐述Linux线程的控制和通信。一组生产者线程与一组消费者线程通过缓冲区发生联系。生产者线程将生产的产品送入缓冲区，消费者线程则从中取出产品。缓冲区有N 个，是一个环形的缓冲池。 ...
生产者和消费者问题以及哲学家就餐问题，JAVA实现的程序.rar
05-27
在"生产者和消费者问题.txt"文件中，可能包含了使用`BlockingQueue`实现生产者消费者问题的Java代码示例，包括如何创建队列，以及生产者和消费者线程如何交互。而"哲学家就餐问题.txt"文件可能展示了如何用Java的...
操作系统课程设计生产者和消费者问题源代码
07-05
（1）创建生产者和消费者线程 在Windows2000环境下，创建一个控制台进程，在此进程中创建n个线程来模拟生产者或者消费者。这些线程的信息由本程序定义的“测试用例文件”中予以指定。 该文件的格式和含义如下： 3 1 ...
Spring Boot 学习和使用
cesske的博客
09-24 1210
Spring Boot是一款开源的Java Web应用框架，旨在简化Spring应用的初始搭建以及开发过程。Spring Boot通过整合Spring技术栈中的诸多关键组件，为开发者提供了一种快速、简便的Spring应用开发方式。它遵循“约定优于配置”的原则，通过自动配置、起步依赖和内置的Servlet容器，极大地简化了传统Spring应用的配置和部署过程。Spring Boot通过其自动化配置、起步依赖、内嵌服务器等特性，极大地简化了Spring应用的开发和部署过程。
工厂模式的介绍及实现
户伟伟的博客
09-25 142
工厂模式（Factory Pattern）是一种创建型设计模式，提供了一种创建对象的接口，而无需显式指定对象的具体类。在这种模式中，我们通过定义一个工厂类，专门负责生产各种类型的对象，这样我们可以避免直接在代码中实例化具体类，使代码更具扩展性、灵活性和维护性。解耦：客户端代码与具体的类解耦，避免了对象创建逻辑的重复。简化对象创建：通过工厂统一管理对象的创建逻辑，使代码更清晰易懂。扩展性强：新增类时，只需在工厂中增加创建逻辑，而不必修改现有的业务代码。
基于JavaWeb开发的Java+SpringMvc+vue+element实现驾校管理系统详细设计
央顺科技官方博客
09-24 1015
机遇与挑战始终并存。在开放的互联网平台面前，驾校预约管理系统的信息管理面临着巨大的挑战。传统的管理模式局限于简单数据的管理，无法适应不断变化的市场格局。在早期阶段，在将计算机技术和网络技术融入驾校预约管理系统数据管理方法之前，所有管理方式都通过人工操作完成了管理信息的。系统管理也都将通过计算机进行整体智能化操作，对于驾校预约管理系统所牵扯的管理及数据保存都是非常多的，举例像所有详细信息包括，管理员；首页、个人中心、学员管理、驾校教练管理、驾校车辆管理、预约管理、取消预约管理、驾校公告管理、系统管理。
Java Alibaba Druid 数据库连接池
miracle的专栏
09-24 789
在Java开发中，数据库连接池是性能优化的重要一环。而作为一款强大的数据库连接池解决方案，凭借其和对多种数据库的支持，成为了许多企业级应用的首选。本篇文章将介绍Druid的核心特性，并结合不同数据库的实际用法。
JPA+Thymeleaf增删改查
y050505的博客
09-25 492
在使用JPA（Java Persistence API）和Thymeleaf作为模板引擎进行Web开发时，实现增删改查（CRUD）操作是一个常见的需求。下面，我将简要介绍如何使用Spring Boot框架结合JPA和Thymeleaf来实现这一功能。
进程管理工具：非daemon进程管理工具supervisor
最新发布
happy_king_zi的博客
09-29 999
supervisor是一个 Client/Server模式的系统，允许用户在类unix操作系统上监视和控制多个进程，或者可以说是多个程序。supervisor与launchd，daemontools，runit等程序有着相同的功能，与其中某些程序不同的是，它并不作为“id 为 1的进程”而替代init。相反，它用于控制应用程序，像启动其它程序一样，通俗理解就是，把Supervisor服务管理的进程程序，它们作为supervisor的子进程来运行，而supervisor是父进程。
生产者和消费者问题pv
11-30
生产者和消费者问题是指在多线程环境下，生产者和消费者之间共享一个固定大小的缓冲区，生产者向缓冲区中生产数据，而消费者从缓冲区中消费数据。生产者和消费者之间需要进行同步，以避免生产者向已满的缓冲区中生产...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值