`

java 生产者消费者示例

 
阅读更多
import java.util.Random;

/**
 * 过程介绍:
 * 1.生产者,pool满,则等待消费;
 * 2.消费者消费,pool空了,则等待生产;
 * 
 * 要点:
 * 1.在什么地方(那个类的对象上)调用wait与notify,让其线程之间协作;
 * 2.必须在协作的原子操作上,加同步;为了便于理解,直接加载了方法上,可以缩小范围;
 */
public class ProducerAndConsumer {
	private static final int sleepTime = 1000;//睡眠时间

	private static final int consumenrThreadNum = 1;//消费者线程数

	private static final int producerThreadNum = 4;//生产者线程数

	public static void main(String[] args) {
		Pool pool = new Pool();
		Consumenr c = new Consumenr(pool);
		Producer p = new Producer(pool);

		for (int i = 0; i < producerThreadNum; i++) {
			Thread producerThread = new Thread(p, " 生产[" + i + "]");
			producerThread.start();
		}
		for (int i = 0; i < consumenrThreadNum; i++) {
			Thread consumenrThread = new Thread(c, "消费[" + i + "]");
			consumenrThread.start();
		}
	}

	/**
	 * 消费者
	 * @author muyx
	 */
	static class Consumenr implements Runnable {
		private Pool pool;

		public Consumenr(Pool pool) {
			this.pool = pool;
		}

		@Override
		public void run() {
			while (true) {
				pool.get();
			}
		}
	}

	/**
	 * 生产者
	 * @author muyx
	 */
	static class Producer implements Runnable {
		private Pool pool;
		private Random r = new Random();

		public Producer(Pool pool) {
			this.pool = pool;
		}

		@Override
		public void run() {
			while (true) {
				pool.put(r.nextInt(10));
			}
		}
	}

	/**
	 * 生产消费的缓冲池
	 * @author muyx
	 */
	static class Pool {
		private int[] pools = new int[10];
		private int cpoint = 0;

		public synchronized void put(int food) {
			Thread t = Thread.currentThread();
			String name = t.getName();
			try {
				if (!isFull()) {
					pools[cpoint++] = food;
					System.out.println(name + this);
					this.notifyAll();
					t.sleep(sleepTime);
				} else {
					System.out.println(name + " 等待中........");
					this.wait();
				}
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}

		public synchronized void get() {
			Thread t = Thread.currentThread();
			String name = t.getName();
			try {
				if (!isEmpty()) {
					pools[--cpoint] = -1;
					this.notifyAll();
					System.out.println(name + this);
					t.sleep(sleepTime);
				} else {
					System.out.println(name + " 等待中.........");
					this.wait();
				}
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}

		public boolean isFull() {
			return this.pools.length == cpoint;
		}

		public boolean isEmpty() {
			return this.cpoint == 0;
		}

		@Override
		public String toString() {
			StringBuilder sb = new StringBuilder("[");
			for (int i = 0, len = pools.length - 1; i < len; i++) {
				sb.append(pools[i] + ",");
			}
			sb.append(pools[pools.length - 1]);
			return sb.append("]").toString();
		}
	}
}


打印结果:
 生产[0][9,0,0,0,0,0,0,0,0,0]
消费[1][-1,0,0,0,0,0,0,0,0,0]
消费[1] 等待中.........
消费[0] 等待中.........
 生产[0][2,0,0,0,0,0,0,0,0,0]
 生产[0][2,2,0,0,0,0,0,0,0,0]
 生产[0][2,2,0,0,0,0,0,0,0,0]
消费[0][2,2,-1,0,0,0,0,0,0,0]
消费[0][2,-1,-1,0,0,0,0,0,0,0]
消费[0][-1,-1,-1,0,0,0,0,0,0,0]
消费[0] 等待中.........
 生产[0][8,-1,-1,0,0,0,0,0,0,0]
 生产[0][8,1,-1,0,0,0,0,0,0,0]
 生产[0][8,1,4,0,0,0,0,0,0,0]

 

分享到:
评论

相关推荐

    java生产者消费者问题

    Java生产者消费者问题是多线程编程中的一个经典问题,它主要涉及到线程间的协作与通信。在并发编程中,生产者负责生成数据,而消费者则负责处理这些数据。为了解决生产者和消费者之间的问题,Java提供了一系列的同步...

    java生产者消费者

    Java生产者消费者模式是一种多线程设计模式,它在并发编程中被广泛使用,用于解决资源的共享问题。在这个模式中,"生产者"负责创建数据,而"消费者"则负责处理这些数据。它们通过一个共享的数据缓冲区进行通信,避免...

    java多线程生产者消费者问题示例

    java多线程学习,生产者消费者问题示例

    java 生产者消费者演示程序

    在这个示例程序中,我们使用了Java语言实现了生产者消费者模型。我们首先创建了一个 GoodsBuffer 对象,该对象充当缓冲区的角色。然后,我们创建了两个生产者对象(Producer),并将其优先级设置为10,这是最高的...

    Java多线程实现生产者消费者

    本示例中的“生产者-消费者”模型是一种经典的多线程问题,它模拟了实际生产环境中的资源分配与消耗过程。下面我们将详细探讨如何在Java中实现这个模型。 首先,我们要理解生产者-消费者模型的基本概念。在这个模型...

    java生产者消费者模型

    Java生产者消费者模型是多线程编程中一种经典的并发控制模型,它源于操作系统中的哲学思想,用于解决资源的共享和异步处理问题。在该模型中,"生产者"线程负责生成数据,而"消费者"线程则负责消费这些数据。两者之间...

    java实现生产者消费者

    在Java编程中,"生产者消费者"模式是一种典型的多线程问题解决模型,它通过共享资源来协调生产者和消费者之间的操作。这个模式的核心在于如何有效地管理资源的生产和消费,以避免生产过快导致资源浪费,或者消费者...

    producer-java.rar_java 生产者 消费者_java 生产者消费者_producer.java_生产者 消费者

    在提供的压缩包文件中,`producer.java`可能是实现生产者消费者问题的Java代码示例。通常,这样的代码会包含两个主要类:一个代表生产者,另一个代表消费者。生产者类会有一个或多个方法用于生成数据并将其放入共享...

    Java生产者消费者问题

    在Java编程领域,生产者消费者问题是多线程同步的一个经典示例,它源自并发编程中的一个常见场景。这个问题描述了两个角色:生产者和消费者,它们共享一个有限大小的缓冲区。生产者负责生成数据并将数据放入缓冲区,...

    JAVA实现线程间同步与互斥生产者消费者问题

    在`JThreadSynch`这个压缩包文件中,我们可以预见到包含的Java源代码将展示以上的一种或多种机制,通过具体的示例代码来解释和实现生产者消费者问题的线程同步和互斥。通过学习和理解这个示例,开发者可以更好地掌握...

    kafka-java-demo 基于java的kafka生产消费者示例

    在"Kafka-java-demo"中,你将看到如何使用这些接口来实现一个简单的生产者和消费者示例。 【Kafka Producer】 Kafka生产者是负责将数据发布到Kafka主题的组件。在Java中,我们可以创建一个Producer实例,配置相关...

    JAVA死锁and生产者消费者问题

    `ProducerConsumer.java`文件可能提供了使用`BlockingQueue`接口实现生产者消费者的示例,`BlockingQueue`已经内置了线程安全的特性,可以自动处理满和空的情况,简化了同步代码。 生产者消费者问题的解决方案通常...

    java IBM MQ 7.5.0 生产者和消费者实例

    在这个“java IBM MQ 7.5.0 生产者和消费者实例”中,我们将探讨如何使用Java编程语言与IBM MQ 7.5.0版本进行交互,创建生产者和消费者应用。 1. **IBM MQ安装与配置**: 在开始编程之前,首先需要在本地或服务器...

    java生产者与消费者问题

    在解压缩后的"proandcom"文件中,可能包含了进一步的代码示例或详细的解释,你可以查看这些文件以加深对生产者消费者问题的理解。同时,为了优化性能和避免死锁,编写多线程程序时,需要遵循良好的设计原则,例如...

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

    以下是一段简单的生产者消费者模式的代码示例: ```java import java.util.concurrent.BlockingQueue; import java.util.concurrent.LinkedBlockingQueue; public class ProducerConsumerExample { public static...

    Java 生产消费者模式

    Java生产消费者模式是一种经典的并发设计模式,用于解决多个线程之间的协作问题。在这个模式中,生产者负责生成数据,而消费者则负责消费这些数据。它基于“缓冲区”概念,即一个有限大小的数据存储区域,生产者将...

    生产者消费者问题java的java编写的

    在提供的代码示例中,`Storage`类扮演了缓冲区的角色,其中的`push()`方法用于添加产品(生产者的行为)而`get()`方法用于取出产品(消费者的行为)。这两个方法都被声明为`synchronized`,这意味着同一时间只有一个...

    java多线程实现生产者消费者关系

    以下是一个简单的基于synchronized关键字和wait/notify机制的生产者消费者示例: ```java import java.util.LinkedList; public class ProducerConsumerExample { private final LinkedList&lt;Object&gt; buffer = new...

Global site tag (gtag.js) - Google Analytics