java—生产者与消费者相关问题研究

最新推荐文章于 2019-11-25 08:32:47 发布
最新推荐文章于 2019-11-25 08:32:47 发布
阅读量116 收藏
点赞数
分类专栏： java基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fang1025780636/article/details/81709740
版权

一：单生产者单消费者：

分析：

  1. 两个线程：生产线程，消费线程
  2. 两个任务：生产任务，消费任务
  3. 一份数据

 

public class Demo03 {
	public static void main(String[] args) {
		//1.准备数据
		Product product = new Product();
		//2.创建生产消费任务
		Producer producer = new Producer(product);
		Consumer consumer = new Consumer(product);
		//3.创建生产消费线程
		Thread thread1 = new Thread(producer);
		Thread thread2 = new Thread(consumer);
		//4.开启线程
		thread1.start();
		thread2.start();
	}
}

// 数据类
class Product {
	String name;
	double price;
	int count;

	// 标识
	boolean flag ;// 默认是false

	// 准备生产
	public synchronized void setProduct(String name, double price) {
		if (flag == true) {
			try {
				wait();
			} catch (Exception e) {
				// TODO: handle exception
				e.printStackTrace();
			}
		}
		this.name = name;
		this.price = price;

		System.out.println(Thread.currentThread().getName() + "生产了：" + name + "  产品的数量：" + count + "  价格是：" + price);

		count++;

		flag = !flag;

		notify();
	}

	// 准备消费
	public synchronized void consume()  {
		if (flag == false) {
			try {
				wait();
			} catch (Exception e) {
				// TODO: handle exception
				e.printStackTrace();
			}
		}
		System.out.println(Thread.currentThread().getName() + "消费了：" + name + "  产品的数量：" + count + "  价格是：" + price);
		flag = !flag;
		notify();
	}
}

// 生产任务
class Producer implements Runnable {
	Product product;

	public Producer(Product product) {
		super();
		this.product = product;
	}

	public void run() {
		int i = 0;
		while (true) {

			product.setProduct("肯德基", 100);

		}
	}
}

// 消费任务
class Consumer implements Runnable {
	Product product;

	public Consumer(Product product) {
		super();
		this.product = product;
	}

	public void run() {
		while (true) {
			product.consume();
		}
	}
}

 

二：多生产者多消费者：

分析

  1. 两个线程：生产线程，消费线程
  2. 两个任务：生产任务，消费任务
  3. 一份数据

 

 错误描述:当有两个生产线程,两个消费线程同时存在的时候,有可能出现生产一次,消费多次或者生产多次消费一次的情况.

 原因:当线程被重新唤醒之后,没有判断标记,直接执行了下面的代码
 
 解决办法:将标记处的if改成while
 
 问题描述:继续运行程序,会出现死锁的情况(4个线程同时处于等待状态)
 原因:唤醒的是本方的线程,最后导致所有的线程都处于等待状态.
 
 解决办法:将notify改成notifyAll.保证将对方的线程唤醒
 
 死锁:出现的情况有两种
 1.所有的线程处于等待状态
 2.锁之间进行嵌套调用

 

public class Demo04 {
	public static void main(String[] args) {
		//1.准备数据
		Product1 product = new Product1();
		//2.创建生产消费任务
		Producer1 producer = new Producer1(product);
		Consumer1 consumer = new Consumer1(product);
		//3.创建生产消费线程
		Thread thread1 = new Thread(producer);
		Thread thread2 = new Thread(consumer);
		Thread thread3 = new Thread(producer);
		Thread thread4 = new Thread(consumer);
		//4.开启线程
		
		thread1.start();
		thread2.start();
		thread3.start();
		thread4.start();
	}
}

// 数据类
class Product1 {
	String name;
	double price;
	int count;

	// 标识
	boolean flag ;// 默认是false
 
	// 准备生产
	public synchronized void setProduct(String name, double price) {
		while (flag == true) {
			try {
				wait();
			} catch (Exception e) {
				// TODO: handle exception
				e.printStackTrace();
			}
		}
		this.name = name;
		this.price = price;

		System.out.println(Thread.currentThread().getName() + "生产了：" + name + "  产品的数量：" + count + "  价格是：" + price);

		count++;

		flag = !flag;

		notifyAll();
	}

	// 准备消费
	public synchronized void consume()  {
		while (flag == false) {
			try {
				wait();
			} catch (Exception e) {
				// TODO: handle exception
				e.printStackTrace();
			}
		}
		System.out.println(Thread.currentThread().getName() + "消费了：" + name + "  产品的数量：" + count + "  价格是：" + price);
		flag = !flag;
		notifyAll();
	}
}

// 生产任务
class Producer1 implements Runnable {
	Product1 product;

	public Producer1(Product1 product) {
		super();
		this.product = product;
	}

	public void run() {
		int i = 0;
		while (true) {

			product.setProduct("肯德基", 100);

		}
	}
}

// 消费任务
class Consumer1 implements Runnable {
	Product1 product;

	public Consumer1(Product1 product) {
		super();
		this.product = product;
	}

	public void run() {
		while (true) {
			product.consume();
		}
	}
}


 研究:研究Lock
  比较synchronized和Lock


  1.synchronized:从jdk1.0就开始使用的同步方法-称为隐式同步
      synchronized(锁对象){//获取锁      我们将锁还可以称为锁旗舰或者监听器
          同步的代码
  }//释放锁


  2.Lock:从jdk1.5开始使用的同步方法-称为显示同步
  
  原理:Lock本身是接口,要通过他的子类创建对象干活儿
  使用过程:
  首先调用lock()方法获取锁
     进行同步的代码块儿
     使用unlock()方法释放锁
   
  使用的场景:
  当进行多生产者多消费者的功能时,使用Lock,其他的都使用synchronized
   
  使用效率上:Lock高于synchronized

public class Demo05 {
	public static void main(String[] args) {
		// 1.准备数据
		Product2 product = new Product2();
		// 2.创建生产消费任务
		Producer2 producer = new Producer2(product);
		Consumer2 consumer = new Consumer2(product);
		// 3.创建生产消费线程
		Thread thread1 = new Thread(producer);
		Thread thread2 = new Thread(consumer);
		Thread thread3 = new Thread(producer);
		Thread thread4 = new Thread(consumer);
		// 4.开启线程

		thread1.start();
		thread2.start();
		thread3.start();
		thread4.start();

	}
}

// 数据类
class Product2 {
	String name;
	double price;
	int count;

	// 标识
	boolean flag;// 默认是false

	// 创建锁对象
	Lock lock = new ReentrantLock();
	
	//获取为生产任务提供唤醒等待的Condition对象
	Condition conditionPro = lock.newCondition();
	//获取为消费任务提供唤醒等待的Condition对象
	Condition conditionCon = lock.newCondition();

	
	// 准备生产
	public void setProduct(String name, double price) {
		try {
			lock.lock();// 获取锁

			while (flag == true) {
				try {
					conditionPro.await();//让生产线程等待
				} catch (Exception e) {
					// TODO: handle exception
					e.printStackTrace();
				}
			}
			this.name = name;
			this.price = price;

			System.out
					.println(Thread.currentThread().getName() + "生产了：" + name + "  产品的数量：" + count + "  价格是：" + price);

			count++;

			flag = !flag;
			
			//肯定唤醒的是消费线程
			conditionCon.signal();
			
		} finally {//放的是必须执行的代码，功能：用于资源的释放
			lock.unlock();// 释放
		}
	}

	// 准备消费
	public void consume() {
		try {
			lock.lock();
			while (flag == false) {
				try {
					conditionCon.await();//让消费进程等待
				} catch (Exception e) {
					// TODO: handle exception
					e.printStackTrace();
				}
			}
			System.out.println(Thread.currentThread().getName() + "消费了：" + name + "  产品的数量：" + count + "  价格是：" + price);
			flag = !flag;
			
			//肯定唤醒的是生产线程
			conditionPro.signal();
			
		} finally {
			// TODO: handle finally clause
			lock.unlock();
		}
		
	}
}

// 生产任务
class Producer2 implements Runnable {
	Product2 product;

	public Producer2(Product2 product) {
		super();
		this.product = product;
	}

	public void run() {
		int i = 0;
		while (true) {

			product.setProduct("肯德基", 100);

		}
	}
}

// 消费任务
class Consumer2 implements Runnable {
	Product2 product;

	public Consumer2(Product2 product) {
		super();
		this.product = product;
	}

	public void run() {
		while (true) {
			product.consume();
		}
	}
}

线程的停止：即如何停止它的任务

  1. 通过一个标识结束线程
  2. 调用stop方法——有固有的安全性问题，系统不推荐使用。
  3. 调用interrupt（）方法。

 

//第一种方式：
/*public class Demo06 {
	public static void main(String[] args) {
		Test test = new Test();
		Thread thread = new Thread(test);
		thread.start();
		
		try {
			thread.sleep(100);
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
		
		
		int i = 0;
		while(true) {
			if(++i==10) {
				test.flag=false;//当主线程执行到某个阶段时，让flag变成false，子线程的任务就会结束，子线程就结束了。
				
				break; //目的是让主线程结束
			}
		}
		
	}
}

class Test implements Runnable {
	boolean flag = true;
	
	public void run() {
		while(flag) {
			System.out.println(Thread.currentThread().getName()+"该下课了");
			
		}
	}
}*/

//第三种方式
public class Demo06 {
	public static void main(String[] args) {
		Test test = new Test();
		Thread thread = new Thread(test);
		thread.start();
		
		try {
			thread.sleep(100);
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
		
		
		int i = 0;
		while(true) {
			if(++i==10) {
				
				//当主线程执行到某个阶段是，调用子线程的Interrupt方法，触发子线程的异常（InterruptedException），让子线程的任务结束，子线程结束
				thread.interrupt();
				break; //目的是让主线程结束
			}
		}
		
	}
}

class Test implements Runnable {
	boolean flag = true;
	
	public synchronized void run() {
		while(flag) {
			try {
				wait();
			} catch (InterruptedException e) {
				flag=false;
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName()+"该下课了");
			
		}
	}
}

 

小小超人不会飞
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java信号量生产者_java信号量PV操作 解决生产者-消费者问题
weixin_36014846的博客
02-21 983
package test1; /** * 该例子演示生产者和消费者的问题(设只有一个缓存空间.一个消费者和一个生产者) * MySystem类定义了缓冲区个数以及信号量 * @author HYY */ public class MySystem { // 缓存区的个数 private int count = 0; // s1 s2为信号量 private MyInt s1 = new MyInt...
Java实现生产者消费者问题与读者写者问题详解
08-28
Java实现生产者消费者问题与读者写者问题详解 Java语言在多线程编程中提供了对同步机制的良好支持，解决生产者/消费者问题的方法可分为两类：（1）采用某种机制保护生产者和消费者之间的同步；（2）在生产者和消费...
生产者消费者问题
做有积累的事
12-16 359
public class ProducerConsumer { /** * @两个生产者一起生产，把product放入栈中，如果满了，等待消费者消费。 * @一个消费者消费，从栈中取，如果没有了，等待生产者生产 */ public static void main(String[] args) { Stack s = new Stack(); new Thread(new P
Java 生产者 与 消费者 的实际运用
ShootCode
10-08 1786
生产者与消费者模式的实际运用
Java经典多线程问题--生产者与消费者
杜鲁门的博客
10-05 772
今天研究了一下Java多线程，顺便写了一下多线程中的经典问题—–生产者消费者经典问题，推荐一个线程链接Java基础知识回顾–线程 这个里面其实写了生产者与消费者问题，估计在后面大家看起来比较费劲，所以我提取出来再讲解一遍。package yanning;public class ProducerConsumer { public static void main(String[] args)
生产者/消费者问题的多种Java实现方式
東方海竹
05-11 1135
实质上，很多后台服务程序并发控制的基本原理都可以归纳为生产者/消费者模式，而这是恰恰是在本科操作系统课堂上老师反复讲解，而我们却视而不见不以为然的。在博文《一种面向作业流(工作流)的轻量级可复用的异步流水开发框架的设计与实现》中将介绍一种生产者/消费者模式的具体应用。 生产者消费者问题是研究多线程程序时绕不开的经典问题之一，它描述是有一块缓冲区作为仓库，生产者可以将产品放入仓库，消费者则...
经典的进程同步问题-----生产者-消费者问题详解
热门推荐
丹丹的后花园
11-25 1万+
经典的进程同步问题-----生产者-消费者问题详解 ​ 本文和接下来几篇博文是对上篇文章（进程同步机制）的一次实践，通过具体的例子来加深理论的理解，会用三个经典的进程同步问题来进行讲解，并且会配有伪代码和Java实践（使用多线程模拟），深入的进行讲解。 ​ 进程同步问题是一个非常重要且相当有趣的问题，因而吸引了很多学者对他进行研究，比如在前几篇博客中提到的老熟人迪杰斯特拉，由此也产生了一系列经典的...
生产者消费者模型java实现
Fighting的博客
09-12 1万+
做题的时候遇到了生产者消费者问题，这个问题可以说是线程学习的经典题目了，就忍不住研究了一波。它描述是有一块缓冲区（队列实现）作为仓库，生产者可以将产品放入仓库，消费者则可以从仓库中取走产品。在Java中这个数组线程阻塞的问题，多个用户同时发送多个请求，怎么保证不发生线程死锁，是我们要考虑的问题。 生产者消费者模式说明： 1.生产者只在仓库未满时进行生产，仓库满时生产者进程被阻塞； 2.消费者...
JAVA线程中的生产者和消费者问题
JAVA前线技术专栏
06-23 1613
生产者消费者问题是研究多线程时绕不开的问题，描述的是有一块生产者和消费者共享的有界缓冲区，生产者往缓冲区放入产品，消费者从缓冲区取走产品，这个过程可以无休止的执行，不能因缓冲区满生产者放不进产品而终止，也不能因缓冲区空消费者无产品可取而终止。 解决生产者消费者问题的方法有两种，一种是采用某种机制保持生产者和消费者之间的同步，一种是在生产者和消费者之间建立一个管道。前一种有较高的效率并且可控制
Java并发编程与技术内幕:消费者-生产者模式研究
Evankaka的专栏
02-27 3261
本文主要实现了生产者和消费者的java代码实现
Java并发之生产者-消费者几种实现
苦行僧
08-01 3239
关于生产者-消费者Java实现，这里看到了一篇写的不错的文章，欢迎补充！ 引用地址：http://blog.csdn.net/monkey_d_meng/article/details/6251879 生产者消费者问题是研究多线程程序时绕不开的经典问题之一，它描述是有一块缓冲区作为仓库，生产者可以将产品放入仓库，消费者则可以从仓库中取走产品。解决生产者/消费者问题的方法可分为两类：
comsumerandproducer.rar_生产者 消费者_生产者与消费者_生产者与消费者问题
09-14
在计算机科学和操作系统领域，"生产者与消费者问题"是一个经典的多线程同步问题，它涉及到如何有效地在多个线程之间共享资源。这个问题通常出现在一个系统中，其中一个或多个线程（生产者）生成数据，而其他线程...
producer-java.rar_java 生产者 消费者_java 生产者消费者_producer.java_生产者 消费者
09-23
在提供的压缩包文件中，`producer.java`可能是实现生产者消费者问题的Java代码示例。通常，这样的代码会包含两个主要类：一个代表生产者，另一个代表消费者。生产者类会有一个或多个方法用于生成数据并将其放入共享...
基于JAVA线程机制研究生产者-消费者问题.pdf
07-02
总之，基于Java线程机制研究生产者-消费者问题，通过实际编码演示了线程创建和管理、线程同步机制的应用，以及如何使用Java提供的数据结构来解决实际问题。这项研究不仅具有理论意义，更具有指导学生实践的意义，...
计算机课程设计 操作系统生产者-消费者问题
01-05
该问题的提出是为了研究 Linux 的进程机制和信号量的实现生产者消费者问题的并发控制。通过研究该问题，可以深入了解操作系统的设计思想和实现方法。 生产者-消费者问题的定义 生产者-消费者问题是一种同步问题的...
弹性力学数值方法：积分法：积分法基本原理.docx
09-01
弹性力学数值方法：积分法：积分法基本原理.docx
autots-0.5.7-py3-none-any.whl.zip
09-01
autots-0.5.7-py3-none-any.whl.zip
AutoTS-0.5.0-py3-none-any.whl.zip
09-01
AutoTS-0.5.0-py3-none-any.whl.zip
基于springboot的医药管理系统设计与实现.docx
最新发布
09-01
基于springboot的医药管理系统设计与实现.docx
Aspeed AST2400 BMC datasheet V14
09-01
Aspeed AST2400 BMC datasheet V14
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值