package com.itcast.threadinfo;
//多生产者与多消费者
//(n-n)
public class Demo1 {
public static void main(String[] args) {
proDemo p = new proDemo();
Procedure pp = new Procedure(p);
Customer cc = new Customer(p);
Thread t1 = new Thread(pp);
Thread t2 = new Thread(pp);
Thread t3 = new Thread(cc);
Thread t4 = new Thread(cc);
t1.start();
t2.start();
t3.start();
t4.start();
}
}
class proDemo {
private String name;
private int count;
private boolean flag = false;
public synchronized void procudeInfo(String name) {
while (flag)
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
this.name = name + count;
count++;
System.out.println(Thread.currentThread().getName()+"生成者..."+this.name);
flag = true;
notifyAll();
}
public synchronized void getcustomer() {
while (!flag)
try {
this.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"消费者..."+name);
flag = false;
notifyAll();
}
}
class Procedure implements Runnable {
proDemo d;
public Procedure(proDemo d) {
this.d = d;
}
@Override
public void run() {
while (true) {
d.procudeInfo("烤鸭");
}
}
}
class Customer implements Runnable {
proDemo d;
public Customer(proDemo d) {
this.d = d;
}
public void run() {
while (true) {
d.getcustomer();
}
}
}
lock替换也行
package com.itcast.threadinfo;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Demo2 {
/**
* @param args
*/
public static void main(String[] args) {
Resouces r=new Resouces();
Pro1 pp=new Pro1(r);
Pro2 cc=new Pro2(r);
Thread t1 = new Thread(pp);
Thread t2 = new Thread(pp);
Thread t3 = new Thread(cc);
Thread t4 = new Thread(cc);
t1.start();
t2.start();
t3.start();
t4.start();
}
}
class Resouces
{
private String name;
private int count;
private boolean flag=false;
Lock lock=new ReentrantLock();
Condition con=lock.newCondition();
public void setInfo(String name)
{
lock.lock();
try{
while(flag)
{
try {
con.await();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
this.name=name+count;
count++;
System.out.println(Thread.currentThread().getName()+"sale 5.0"+this.name);
flag=true;
con.signalAll();
}
finally{
lock.unlock();
}
}
public void getpro()
{
lock.lock();
try{
while(!flag)
{
try {
con.await();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName()+"消费者 5.0"+name);
flag=false;
con.signalAll();
}
finally
{
lock.unlock();
}
}
}
class Pro1 implements Runnable{
Resouces r;
public Pro1(Resouces r)
{
this.r=r;
}
@Override
public void run() {
while(true){
r.setInfo("烤鸡");}
}}
class Pro2 implements Runnable{
Resouces r;
public Pro2(Resouces r){this.r=r;}
@Override
public void run() {
while(true){
r.getpro();}
}
}
相关推荐
9. **测试与调试**:多线程问题往往难以复现,因此在编写生产者-消费者代码时,应编写充分的测试用例,包括边界情况,如缓冲区满和空的状态转换。 通过理解和掌握这些知识点,开发者能够有效地实现生产者-消费者...
本示例中的“生产者-消费者”模型是一种经典的多线程问题,它模拟了实际生产环境中的资源分配与消耗过程。下面我们将详细探讨如何在Java中实现这个模型。 首先,我们要理解生产者-消费者模型的基本概念。在这个模型...
java多线程经典模型生产者消费者java多线程经典模型生产者消费者java多线程经典模型生产者消费者java多线程经典模型生产者消费者java多线程经典模型生产者消费者java多线程经典模型生产者消费者java多线程经典模型...
4. **阻塞队列(BlockingQueue)**:Java并发包(java.util.concurrent)中的阻塞队列是实现生产者消费者模式的理想选择。它们在内部已经处理了线程同步和等待,提供了一种高效且安全的共享数据方式。例如,`put()`...
java实现多线程经典模型生产者消费java实现多线程经典模型生产者消费java实现多线程经典模型生产者消费java实现多线程经典模型生产者消费java实现多线程经典模型生产者消费java实现多线程经典模型生产者消费java实现...
本项目通过一个生产者消费者问题的实例,展示了如何在Java中实现线程间的同步与互斥。 生产者消费者问题是经典的并发问题之一,它涉及到两个类型的线程:生产者和消费者。生产者负责生成数据(产品),而消费者则...
Java线程安全与生产者消费者模型是多线程编程中的两个重要概念,它们在并发处理中扮演着关键角色。在Java中,线程安全是指一个类或者方法在多线程环境下能够正确地处理数据,避免数据的不一致性或竞态条件。而生产者...
生产者消费者模式是一种经典的多线程同步问题解决方案,它源于现实世界中的生产流水线,用于描述生产者(Producer)和消费者(Consumer)之间的协作关系。在这个模式中,生产者负责生成产品并放入仓库,而消费者则从...
在实际应用中,我们常常会遇到一种典型的多线程问题——生产者消费者模型。这个模型描述了两种类型的线程:生产者线程负责创建或生产资源,而消费者线程则负责消耗这些资源。在Java中,我们可以利用同步机制来实现...
使用wait()和notify()实现的生产者与消费者模型,可以了解如何使用wait()和notify()进行线程间通信。(上一次上传的代码有一个问题没有考虑到,这次修补了——CSDN没法撤销资源,只能再上传了)
用java多线程,实现生产者消费者同步和互斥的问题,操作系统中的经典问题
基本满足操作系统课上要求,java实现的生产者消费者模型。
生产者-消费者模式是一种经典的多线程设计模式,用于解决数据共享问题,尤其是在一个线程生产数据而另一个线程消费数据的情况下。在这个模式中,生产者负责生成数据并放入共享的数据结构(如队列),而消费者则从这...
Java线程实现的生产者和消费者程序是一种经典的多线程设计模式,用于处理并发操作中的数据共享问题。这种模式在实际编程中广泛应用,特别是在需要高效处理数据流和资源管理的系统中。以下将详细讲解其核心概念、实现...
### 由生产者/消费者问题深入理解JAVA多线程 #### 生产者/消费者问题概述 生产者/消费者问题是一个经典的计算机科学问题,用于展示进程间的通信与同步问题。在这个模型中,生产者负责创建数据并将其放置到共享内存...
用Java实现消费者与生产者两个线程进行调度
Java多线程编程是开发高并发、高性能应用的关键技术之一,而生产者消费者模式是多线程编程中常用的一种设计模式。它通过分离数据的生产和消费过程,实现了线程间的协同工作,有效避免了资源的竞争和浪费。在这个模式...
Java多线程生产者消费者模型是一种典型的线程协作模式,用于解决并发编程中资源的高效利用和同步问题。在这个模型中,"生产者"线程负责生成数据,而"消费者"线程则负责处理这些数据。为了实现这种模式,Java提供了...
在Java多线程编程中,消费者-生产者模型是一种经典的线程间通信模式,用于解决多线程环境下的数据共享问题。该模型涉及到两个主要的角色:生产者(Producer)和消费者(Consumer)。生产者负责创建数据,而消费者则...