`

java 多线程 producer customer

阅读更多
package com.thread2;

//java多线程模拟生产者消费者问题
//ProducerConsumer是主类,Producer生产者,Consumer消费者,Product产品
//Storage仓库
public class ProducerConsumer {

	public static void main(String[] args) {
		Storage s = new Storage();
		Producer p = new Producer(s);
		Consumer c = new Consumer(s);
		Thread tp = new Thread(p);
		Thread tc = new Thread(c);
		tp.start();
		tc.start();

	}
}

class Consumer implements Runnable {// 消费者
	Storage s = null;

	public Consumer(Storage s) {
		this.s = s;
	}

	public void run() {
		for (int i = 0; i < 20; i++) {
			Product p = s.pop();// 取出产品
			try {
				Thread.sleep((int) (Math.random() * 1500));
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}

	}

}

class Producer implements Runnable {// 生产者
	Storage s = null;

	public Producer(Storage s) {
		this.s = s;
	}

	public void run() {
		for (int i = 0; i < 20; i++) {
			Product p = new Product(i);
			s.push(p); // 放入产品
			// System.out.println("生产者放入:" + p);
			try {
				Thread.sleep((int) (Math.random() * 1500));
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}

	}
}

class Product {
	int id;

	public Product(int id) {
		this.id = id;
	}

	public String toString() {// 重写toString方法
		return "产品:" + this.id;
	}
}

class Storage {
	int index = 0;
	Product[] products = new Product[5];

	public synchronized void push(Product p) {// 放入
		while (index == this.products.length) {
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		this.products[index] = p;
		System.out.println("生产者放入" + index + "位置:" + p);
		index++;
		this.notifyAll();
	}

	public synchronized Product pop() {// 取出
		while (this.index == 0) {
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		index--;
		this.notifyAll();
		System.out.println("消费者从" + index + "位置取出:" + this.products[index]);
		return this.products[index];
	}
}
 wait导致当前的线程等待,直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法。
wait(),notify(),notifyAll()不属于Thread类,而是属于Object基础类,也就是说每个对像都有wait(),notify(),notifyAll()的功能.因为都个对像都有锁,锁是每个对像的基础,当然操作锁的方法也是最基础了. 




package com.test.thread;

import java.util.ArrayList;
import java.util.List;

public class CustomerProducer {
	public static void main(String args[]){
		Storage s = new Storage();
		Producer p = new Producer(s);
		Customer c = new Customer(s);
		Thread tp = new Thread(p);
		Thread cp = new Thread(c);
		tp.start();
		cp.start();
	}
}
class Storage{
	List<String> storage = new ArrayList<String>();
	int maxLength = 10;
	int index = 0;
	public synchronized void push(String goods){
		while(this.index == maxLength){
			try{
				System.out.println("push wait");
				this.wait();
			}catch(Exception ex){
				ex.printStackTrace();
			}
		}
		storage.add(goods);
		System.out.println("producer index:"+(index+1));
		index++;
		this.notifyAll();
	}
	
	public synchronized String pop(){
		while(this.index == 0){
			try{
				System.out.println("pop wait");
				this.wait();
			}catch(Exception ex){
				ex.printStackTrace();
			}
		}
		String tmp = storage.remove(index-1);
		System.out.println("customer index:"+index);
		index--;
		this.notifyAll();
		return tmp;
	}
}
class Producer implements Runnable{
	Storage s = null;
	public Producer(Storage s){
		this.s = s;
	}
	public void run(){
		for(int i = 0;i<10;i++){
			String goods = String.valueOf(i);
			s.push(goods);
			try{
				Thread.sleep((int)(Math.random()*1000));
			}catch(InterruptedException e){
				e.printStackTrace();
			}
		}
	}
}
class Customer implements Runnable{
	Storage s = null;
	public Customer(Storage s){
		this.s = s;
	}
	public void run(){
		for(int i = 0;i<10;i++){
//			String str = s.pop();
//			System.out.println(str);
			s.pop();
			try{
				Thread.sleep((int)(Math.random()*3000));
			}catch(Exception ex){
				ex.printStackTrace();
			}
		}
	}
}
分享到:
评论

相关推荐

    Java多线程-生产者与消费者问题

    ### Java多线程-生产者与消费者问题 #### 一、生产者与消费者问题概览 **1.1 概要** 生产者与消费者问题是计算机科学中一个多线程同步的经典问题。它描述了两个线程如何共享有限资源的场景:一个是生产者...

    java中的 双线程,举一反三

    本主题将深入探讨“双线程”概念,并通过分析提供的类文件(Store、Customer、Producer、Market及Market.java)来举例说明。 首先,我们要明白Java中的线程有两种创建方式:通过实现Runnable接口或继承Thread类。...

    Java多线程 生产者消费者模型实例详解

    Java多线程生产者消费者模型实例详解 Java多线程生产者消费者模型是指在多线程环境下,生产者线程生产任务,消费者线程消费任务,而缓冲区是生产者和消费者之间的媒介。生产者消费者模型的主要组成部分包括生产者...

    java 生产者消费者演示程序

    2. Java 多线程机制:Java 提供了多种多线程机制,包括 Thread 类、Runnable 接口等,可以用来实现并发执行。 3. 缓冲区:缓冲区是生产者消费者模型中的核心组件,用于存储生产者的产品,以便消费者消费。 4. 优先级...

    计算机操作系统实验-生产者和消费者(java)

    在 Java 中,我们可以使用多线程编程和同步机制来实现生产者-消费者模型。 生产者-消费者模型的定义 生产者-消费者模型是一种同步机制,用于解决多线程之间的数据共享和访问问题。生产者负责生产数据,并将其存储...

    栈的先进后出的算法演示程序.doc

    本资源是一个 Java 实现的栈的先进后出的算法演示程序,展示了栈的基本操作和多线程同步机制的应用。 一、栈的基本概念 栈是一种基本的数据结构,遵循先进后出(FILO)的原则,即最后入栈的元素最先被取出。栈的...

    多个生产者消费者问题

    通过上述分析可以看出,本程序很好地展示了如何使用Java语言实现多线程环境下的生产者-消费者模式。通过对线程调用的深入分析,不仅能够帮助我们更好地理解多线程编程的基本原理,还能够提高我们在实际开发中解决...

    produce-customer.rar_操作系统_生产者_生产者 消费者_生产者消费者_生产者进程

    这个问题通常用于演示多线程同步和通信的概念。 生产者-消费者问题是这样一种情景:一个或多个“生产者”线程负责创建或生产某种资源,而一个或多个“消费者”线程则负责消耗这些资源。中间有一个共享的缓冲区,...

    AuTheatre:这是Java中剧院票房内部工作的面向对象实现。

    此外,Java的并发工具也可能被用来处理多线程环境下的并发问题,比如当多个用户同时购票时。 在AuTheatre-main文件夹中,包含了这个项目的主要源代码文件和可能的配置文件。这些文件通常以.java为扩展名,是Java...

    数据库缓存技术文档 缓存 数据库

    虽然实际的数据库缓存系统可能更复杂,但这个例子提供了一个基础的多线程模型。 在`Producer`类中,数据被写入一个本地文件("myvector.obj"),这里可以视为一种简单的内存之外的缓存形式。`ObjectOutputStream`...

    activemq 集群配置文档

    - **定义**: 会话是生产和消费消息的单线程上下文。 - **功能**: 会话用于创建消息生产者、消息消费者以及消息本身,并且提供了一个事务性的上下文。这意味着一组发送和接收操作可以被组合成一个原子操作,以确保...

Global site tag (gtag.js) - Google Analytics