多线程之生产者和消费者模式

package com.git.base.thread.productandconsumer;
/**
 * 核心实现:
 * 生产者消费者模式:
 * 生产一个,消费一个,如果生产未被消费,那么就等待消费后再生产
 * 如果消费后,没有下一个生产的,就等待生产后在消费
 * <p>Title: DoMain.java</p>
 * <p>Description: </p>
 * <p>Copyright: Copyright (c) 2016</p>
 * <p>Company: Sage</p>
 * @author 五虎将
 * @date 2016年5月9日下午10:59:51
 * @version 1.0
 */
public class DoMain {

	public static void main(String[] args) {
		Info info = new Info();
		ProductInfo product = new ProductInfo(info);
		ConsumerInfo consumer = new ConsumerInfo(info);

		Thread t1 = new Thread(product);
		Thread t2 = new Thread(consumer);
		t1.start();
		t2.start();
	}
}

package com.git.base.thread.productandconsumer;

/**
 * 中间信息类-核心类!!!
 * 生产者进行生产及消费者进行消费
 * 生产者消费者模式的解决点在中间过渡物体类中
 * 保证中间类的线程唯一性 从而解决多线程问题
 * 什么是多线程问题?其实就是多线程变为单线程再某些点上!
 * <p>Title: Info.java</p>
 * <p>Description: </p>
 * <p>Copyright: Copyright (c) 2016</p>
 * <p>Company: Sage</p>
 * @author 五虎将
 * @date 2016年5月9日下午10:42:08
 * @version 1.0
 */
public class Info {

	private String name;

	private String content;

	private boolean flag = false;

/*	1变
	public synchronized void set(String name,String content){
		this.name = name;
		this.content = content;
	}

	public synchronized void get(){
		System.out.println(this.name +" =====" + this.content);
	}
*/	

	public synchronized void set(String name,String content){
		if(flag){
			try {
				super.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
			this.name = name;
			this.content = content;
			try {
				Thread.sleep(200);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			flag = true;
			super.notify();

	}

	public synchronized void get(){
		if(!flag){
			try {
				super.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
			System.out.println(this.name +" =====" + this.content);
			try {
				Thread.sleep(200);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			flag = false;
			super.notify();

	}

	public String getName() {
		return name;
	}

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

	public String getContent() {
		return content;
	}

	public void setContent(String content) {
		this.content = content;
	}

}
package com.git.base.thread.productandconsumer;

public class ConsumerInfo implements Runnable{

	private Info info;

	public ConsumerInfo(Info info) {
		this.info = info;
	}

	@Override
	public void run() {
		for (int i = 0; i < 100; i++) {
			try {
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			info.get();
		}
	}

}
package com.git.base.thread.productandconsumer;

public class ProductInfo implements Runnable{

	private boolean flag = true;

	private Info info;

	public ProductInfo(Info info) {
		this.info = info;
	}

	@Override
	public void run() {
		for (int i = 0; i < 100; i++) {
				if(flag){
					info.set("宋庆虎","喜欢分布式");
					try {
						Thread.sleep(200);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					flag = false;
				}else{
					info.set("龙志建", "喜欢JAVA");
					try {
						Thread.sleep(200);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					flag = true;
				}
		}
	}

}
时间: 2024-08-29 00:10:35

多线程之生产者和消费者模式的相关文章

多线程生产者、消费者模式中,如何停止消费者?多生产者情况下对“毒丸”策略的应用。

生产者.消费者模式是多线程中的经典问题.通过中间的缓冲队列,使得生产者和消费者的速度可以相互调节. 对于比较常见的单生产者.多消费者的情况,主要有以下两种策略: 通过volatile boolean producerDone =false 来标示是否完成.生产者结束后标示为true, 消费者轮询这个变量来决定自己是否退出. 这种方式对producerDone产生比较大的争用,实现起来也有诸多问题需要考虑. 比较经典的"毒丸"策略,生产者结束后,把一个特别的对象:"毒丸&quo

Java多线程设计模式(2)生产者与消费者模式

1 Producer-Consumer Pattern Producer-Consumer Pattern主要就是在生产者与消费者之间建立一个“桥梁参与者”,用来解决生产者线程与消费者线程之间速度的不匹配. 当要从某个线程Produccer参与者将数据传输给其它线程Consumer参与者的时候,此时就可以在中间加一个Channel参与者,在Channel参与者中以某种方式存放接受的数据,再以某方式来获取收到的数据,Channel就可以来缓存两个线程之间传输的数据,在Channel参与者为了保证安

Java多线程学习笔记--生产消费者模式

实际开发中,我们经常会接触到生产消费者模型,如:Android的Looper相应handler处理UI操作,Socket通信的响应过程.数据缓冲区在文件读写应用等.强大的模型框架,鉴于本人水平有限目前水平只能膜拜,本次只能算学习笔记,为了巩固自己对Java多线程常规知识点的理解,路过大神还望能指导指导.下面一段代码是最常规的生产者消费者的例子: package com.zhanglei.demo; import java.util.ArrayList; import java.util.List

python实现生产者和消费者模式

利用python的线程实现简单生产者和消费者模式,这种模式在多线程编程时还是用的比较多吧,下面是源代码: 1 #!/usr/bin/python 2 # -*- coding: utf-8 -*- 3 import requests,time 4 import threading,queue 5 6 7 class mythread_1(threading.Thread): 8 def __init__(self,queue): 9 super(mythread_1,self).__init__

python 生产者与消费者模式

生产者与消费者模式 1. 队列 先进先出 2. 栈 先进后出 Python的Queue模块中提供了同步的.线程安全的队列类,包括FIFO(先入先出)队列Queue,LIFO(后入先出)队列LifoQueue,和优先级队列PriorityQueue.这些队列都实现了锁原语(可以理解为原子操作,即要么不做,要么就做完),能够在多线程中直接使用.可以使用队列来实现线程间的同步. 用FIFO队列实现上述生产者与消费者问题的代码如下: import threading import time from q

实现生产者与消费者模式

实现生产者与消费者模式 目录 生产者与消费者模式 实现 生产者与消费者模式 什么是生产者消费者模式 生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题.生产者和消费者彼此之间不直接通讯,而通过阻塞队列来进行通讯,所以生产者生产完数据之后不用等待消费者处理,直接扔给阻塞队列,消费者不找生产者要数据,而是直接从阻塞队列里取,阻塞队列就相当于一个缓冲区,平衡了生产者和消费者的处理能力. 这个阻塞队列就是用来给生产者和消费者解耦的.纵观大多数设计模式,都会找一个第三者出来进行解耦,如工厂模式

Java多线程的生产者与消费者模型,线程间的通信

java多线程中的生产者与消费者模式:首先有一个阻塞队列,生产者将生产的东西放到队列里,消费者再从队列中取.当队列中的东西数量达到其容量就发生阻塞. import java.util.Random; import java.util.concurrent.ArrayBlockingQueue; import java.util.concurrent.BlockingQueue; import java.util.concurrent.LinkedBlockingQueue; import jav

同步函数 生产者和消费者模式 加强版(多人生产和多人消费)

曾经搞了半天, 生产者和消费者模式  加强版(多人生产 多人消费 ).. 以前的代码格式就不再吐槽了(以后努力改进) //输出结果是一个无限循环 import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /** * 多个生产者&多个消费者模式 * 多个生产者不断生产,多个消费者不停的消费

Linux:生产者与消费者模式

生产者:生产数据 消费者:消费数据 提供场所:缓冲区,eg:超市 生产者消费者特点:三种关系,两类人,一个场所 三种关系指的是:生产者与生产者之间是互斥关系 消费者与消费者之间是互斥关系 生产者与消费者之间是同步与互斥关系 两类人:生产者,消费者 一个场所:存储数据(此处用带头单链表实现) 单生产者单消费者模式:此例取数据方式为FIFO先进先出. 利用互斥锁实现单生产者单消费者模式. #include<stdio.h> #include<malloc.h> #include<