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多线程-生产者与消费者问题 #### 一、生产者与消费者问题概览 **1.1 概要** 生产者与消费者问题是计算机科学中一个多线程同步的经典问题。它描述了两个线程如何共享有限资源的场景:一个是生产者...
本主题将深入探讨“双线程”概念,并通过分析提供的类文件(Store、Customer、Producer、Market及Market.java)来举例说明。 首先,我们要明白Java中的线程有两种创建方式:通过实现Runnable接口或继承Thread类。...
Java多线程生产者消费者模型实例详解 Java多线程生产者消费者模型是指在多线程环境下,生产者线程生产任务,消费者线程消费任务,而缓冲区是生产者和消费者之间的媒介。生产者消费者模型的主要组成部分包括生产者...
2. Java 多线程机制:Java 提供了多种多线程机制,包括 Thread 类、Runnable 接口等,可以用来实现并发执行。 3. 缓冲区:缓冲区是生产者消费者模型中的核心组件,用于存储生产者的产品,以便消费者消费。 4. 优先级...
在 Java 中,我们可以使用多线程编程和同步机制来实现生产者-消费者模型。 生产者-消费者模型的定义 生产者-消费者模型是一种同步机制,用于解决多线程之间的数据共享和访问问题。生产者负责生产数据,并将其存储...
本资源是一个 Java 实现的栈的先进后出的算法演示程序,展示了栈的基本操作和多线程同步机制的应用。 一、栈的基本概念 栈是一种基本的数据结构,遵循先进后出(FILO)的原则,即最后入栈的元素最先被取出。栈的...
通过上述分析可以看出,本程序很好地展示了如何使用Java语言实现多线程环境下的生产者-消费者模式。通过对线程调用的深入分析,不仅能够帮助我们更好地理解多线程编程的基本原理,还能够提高我们在实际开发中解决...
这个问题通常用于演示多线程同步和通信的概念。 生产者-消费者问题是这样一种情景:一个或多个“生产者”线程负责创建或生产某种资源,而一个或多个“消费者”线程则负责消耗这些资源。中间有一个共享的缓冲区,...
此外,Java的并发工具也可能被用来处理多线程环境下的并发问题,比如当多个用户同时购票时。 在AuTheatre-main文件夹中,包含了这个项目的主要源代码文件和可能的配置文件。这些文件通常以.java为扩展名,是Java...
虽然实际的数据库缓存系统可能更复杂,但这个例子提供了一个基础的多线程模型。 在`Producer`类中,数据被写入一个本地文件("myvector.obj"),这里可以视为一种简单的内存之外的缓存形式。`ObjectOutputStream`...
- **定义**: 会话是生产和消费消息的单线程上下文。 - **功能**: 会话用于创建消息生产者、消息消费者以及消息本身,并且提供了一个事务性的上下文。这意味着一组发送和接收操作可以被组合成一个原子操作,以确保...