多线程生产者消费者模式

闲着没事,写了个生产者消费者模式玩玩,顺便熟悉下notify的用法。

package sync;

public class Test {

	public static void main(String[] args) {

		Test test = new Test();
		Producer producer = test.new Producer();
		producer.start();

		Consumer consumer = test.new Consumer();
		consumer.setName("consumer   0======");
		consumer.start();

		Consumer consumer1 = test.new Consumer();
		consumer1.setName("consumer  1======");
		consumer1.start();

		Consumer consumer2 = test.new Consumer();
		consumer2.setName("consumer  2======");
		consumer2.start();
	}

	/**
	 * @Desc 仓库   (这是个内部静态类)
	 * @author liuxingmi
	 * @QQ 63972012
	 */
	static class Factory {

		volatile int count = 0;
		boolean flag = true;
		private static Factory instance = new Factory();
		public static Factory getInstance(){
			if(instance == null){
				instance = new Factory();
			}
			return instance;
		}

		public synchronized void producer() {
			if (count >= 5) {
				flag = false;
				this.notifyAll();
				try {
					this.wait();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}

			count++;
			System.out.println("producer count = " + count);
			try {
				Thread.sleep(500);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}

		public synchronized void consumer() {

			if (!flag) {
				System.out.println( Thread.currentThread().getName() + "start count = " + count + " times:" + System.currentTimeMillis());
				if (count <= 0) {
					try {
						flag = true;
						this.notify();
						this.wait();

					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
				if(count > 0){//这个地方一定要判断,因为notify是随机唤醒线程,如果不判断在一个生产者,多个消费者情况下会出现负数的情况
					count--;
					System.out.println( Thread.currentThread().getName() + " count = " + count);
				}

				try {
					Thread.sleep(500);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}

	/**
	 * @Desc 生产者
	 * @author liuxingmi
	 * @QQ 63972012
	 */
	class Producer extends Thread {

		Factory factory = Factory.getInstance();

		@Override
		public void run() {

			while (true) {
				factory.producer();

			}
		}
	}

	/**
	 * @Desc 消费者
	 * @author liuxingmi
	 * @QQ 63972012
	 */
	class Consumer extends Thread {

		Factory factory = Factory.getInstance();

		@Override
		public void run() {

			while (true) {
				factory.consumer();

			}
		}
	}
}
时间: 2024-11-13 18:32:08

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

java多线程 生产者消费者模式

package de.bvb; /** * 生产者消费者模式 * 通过 wait() 和 notify() 通信方法实现 * */ public class Test1 { public static void main(String[] args) { Godown godown = new Godown(50); for (int i = 0; i < 5; i++) { new ProducerThread(i * 10, godown).start(); new ConsumerThre

java 多线程-生产者消费者模式-管程法

生产者消费者模式管程法通过容器中介,将数据放入和取出 wait()导致当前线程等待,直到另一个线程调用该对象的notify()或notyfyAll()方法notify()唤醒正在等待对象监视器的单个线程,notifyAll()唤醒正在等待对象监视器的所有线程 public class tuble { public static void main(String[]args) { SynContainer container=new SynContainer(); new Productor(co

多线程生产者/消费者模式实现

参考书籍<java多线程编程核心技术> 都是基于wait/notify实现的 一个生产者和一个消费者:操作值 1 package com.qf.test10.pojo; 2 3 /** 4 * @author qf 5 * @create 2018-09-18 15:59 6 */ 7 public class Entity { 8 public static String value = ""; 9 } 1 package com.qf.test10; 2 3 impor

Java多线程-生产者/消费者模式实现

单生产者与单消费者 示例: public class ProduceConsume { public static void main(String[] args) { String lock = new String(""); Produce produce = new Produce(lock); Consume consume = new Consume(lock); new Thread(() -> { while (true) { produce.setValue();

多线程的并发执行应用(生产者消费者模式)

在实际的开发中我们为了提高CPU的利用率,也提高程序的执行效率,我们经常使用多线程进行对数据进行并发处理,下面我举一个多线程并发执行的实例,大致意思就是 一个简单的生产者消费者模式,二个线程进行存数据,一个线程进行取数据. import java.util.concurrent.ArrayBlockingQueue; import java.util.concurrent.BlockingQueue; public class BlockingQueueTest { /** * @param a

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

最近在项目中需要使用使用多线程实现一种功能,和生产者消费者模式类似,因此,学习了下生产者消费者模式的多线程实现.在生产者消费者模式中,通常有两类线程, 即若干个生产者线程和若干个消费者线程.生产者线程负责提交用户请求,消费者线程则负责处理生产者提交的任务.生产者和消费者之间则通过共享内存缓冲区进行通信. 在这里我们选择BlockingQueue做为共享内存缓冲区. 首先,我们构建生产者生产的,和消费者需要处理的数据PCData,即相关任务数据. public class PCData { pri

多线程:生产者/消费者模式

生产者/消费者模式 实际上,很多后台服务程序并发控制的基本原理都可以归纳为生产者/消费者模式. 生产者消费问题是研究多线程程序时绕不开的经典问题之一,它描述是有一块缓冲区作为仓库,消费者则可以从仓库中取走产品.解决生产者/消费者问题的方法可以分为两类: 采用某种机制保护生产者和消费者之间的同步: 生产者和消费者之间建立一个管道. 第一种方式有较高的效率,并且易于实现,代码的可控制性较好,属于常用的模式. 第二种管道缓冲不易控制,被传输数据对象不易于封装,实用性不强. 同步问题的核心在于:如何保证

java 多线程并发系列之 生产者消费者模式的两种实现

在并发编程中使用生产者和消费者模式能够解决绝大多数并发问题.该模式通过平衡生产线程和消费线程的工作能力来提高程序的整体处理数据的速度. 为什么要使用生产者和消费者模式 在线程世界里,生产者就是生产数据的线程,消费者就是消费数据的线程.在多线程开发当中,如果生产者处理速度很快,而消费者处理速度很慢,那么生产者就必须等待消费者处理完,才能继续生产数据.同样的道理,如果消费者的处理能力大于生产者,那么消费者就必须等待生产者.为了解决这种生产消费能力不均衡的问题,所以便有了生产者和消费者模式. 什么是生

java 多线程 22 :生产者/消费者模式 进阶 利用await()/signal()实现

java多线程15 :wait()和notify() 的生产者/消费者模式 在这一章已经实现了  wait/notify 生产消费模型 利用await()/signal()实现生产者和消费者模型 一样,先定义一个缓冲区: public class ValueObject { public static String value = ""; } 换种写法,生产和消费方法放在一个类里面: public class ThreadDomain41 extends ReentrantLock {