生产者与消费者java
⑴ java中关于消费者和生产者的问题
publicclassProcerConsumer_3
{
publicstaticvoidmain(String[]args)
{
=newSyncStack();
Procerp=newProcer(ss);
Consumerc=newConsumer(ss);
Threadt1=newThread(p);
Threadt2=newThread(c);
t1.start();
t2.start();
}
}
classSyncStack
{
intcnt=0;
char[]data=newchar[6];
publicsynchronizedvoidpush(charch)
{
while(cnt==data.length)
{
try
{
this.wait(); //wait是Object类中的方法，不是Thread中的方法，Thread中wait也是继承自Object,
//this.wait();不是让当前对象wait，而是让当前锁定this对象的线程wait，同时释放对this的锁定。
//注意：如果该对象没有被锁定，则调用wait方法就会报错！即只有在同步方法或者同步代码块中才可以调用wait方法，notify同理
}
catch(Exceptione)
{
}
}
this.notify();//如果注释掉了本语句，可能会导致消费线程陷入阻塞(如果消费线程本身执行很慢的话，则消费线程永远不会wait，即永远不会阻塞)，因为消费线程陷入阻塞，所以生产线程因此不停生产产品达到6个后也陷入阻塞，最后显示的肯定是“容器中现在共有6个字符!”
//this.notify();叫醒一个现在正在waitthis对象的一个线程，如果有多个线程正在waitthis对象，通常是叫醒最先waitthis对象的线程,但具体是叫醒哪一个，这是由系统调度器控制，程序员无法控制
//nority和notifyAll都是Object类中的方法
data[cnt]=ch;
cnt++;
System.out.printf("生产了:%c ",ch);
System.out.printf("容器中现在共有%d个字符! ",cnt);
}
publicsynchronizedcharpop()
{
charch;
while(0==cnt)
{
try
{
this.wait();
}
catch(Exceptione)
{
}
}
this.notify();//如果注释掉了本语句，可能会导致生产线程陷入阻塞(如果生产线程本身执行很慢的话，则生产线程永远不会wait，即永远不会阻塞)，因为生产线程陷入阻塞，消费线程因此不停取出产品，当容器中再也没有产品时消费线程也陷入阻塞，最后显示的肯定是“容器中现在共有0个字符!”
ch=data[cnt-1];
--cnt;
System.out.printf("取出:%c ",ch);
System.out.printf("容器中现在共有%d个字符! ",cnt);
returnch;
}
}
classProcerimplementsRunnable
{
SyncStackss=null;
publicProcer(SyncStackss)
{
this.ss=ss;
}
publicvoidrun()
{
charch;
//总共生产20个产品
for(inti=0;i<20;++i)
{
ch=(char)('a'+i);
ss.push(ch);
// try
// {
// Thread.sleep(500);
// }
// catch(Exceptione)
// {
// }
}
}
}
{
SyncStackss=null;
publicConsumer(SyncStackss)
{
this.ss=ss;
}
//总共消费20个产品
publicvoidrun()
{
for(inti=0;i<20;++i)
{
ss.pop();
try
{
Thread.sleep(500);
}
catch(Exceptione)
{
}
}
}
}
⑵ java中生产者和消费者问题
好不好，要看情况，单这样，提不提都问题不大。
类的架构，由设计者决定。
this 是指当前类的当前实例
⑶ java多生产者和多消费者
public static void main(String[] args) {
Buffer buffer=new Buffer(); //创建一个临界区对象
new Procer(buffer,100).start(); //创建一个生产者对象，并启动其线程
new Consumer(buffer,200).start(); //创建一个消费者对象，并启动其线程
new Consumer(buffer,201).start(); //创建第二个消费者对象，并启动其线程
}
这一段代码，多加入
new Consumer(buffer,201).start(); //创建第二个消费者对象，并启动其线程
多加一段代码创建一个消费者
多加入
new Procer(buffer,100).start();
创建一个生产者。
想要很多生产者和消费者？加就是了啊。
第四个文件 Buffer.java
这个是实现同步的主要缓存类。想要实现同步
在每个方法的声明前都加入synchronized 就行
synchronized 线程锁，很好用的。源代码已经加入了
就比如
public synchronized void put(int value) { //同步方法控制临界区内容写入
⑷ Java线程生产者与消费者
改成这样就可以了
class WoTou {
int id;
WoTou(int id) {
this.id=id;
}
public String toString() {
return "WoTou"+id;
}
}
class SynStack {
WoTou[] ss = new WoTou[6];
int index;
SynStack(int index) {
this.index=index;
}
public synchronized void push(WoTou wt) {
while(index==ss.length) {
try {
this.wait();
}catch (InterruptedException e) {
e.printStackTrace();
}
}
this.notify();
ss[index]=wt;
index++;
}
public synchronized WoTou pop() {
while(index==0) {
try {
this.wait();
}catch(InterruptedException e) {
e.printStackTrace();
}
}
this.notify();
index--;
return ss[index];
}
}
class Procer implements Runnable{
SynStack syn;
Procer(SynStack syn) {
this.syn=syn;
}
public void proceWoTou() {
for(int i=0;i<20;i++) {
WoTou wt = new WoTou(i);
syn.push(wt);
System.out.println("生产了一个"+wt);
try {
Thread.sleep(200);
} catch(InterruptedException e) {
e.printStackTrace();
}
}
}
public void run() {
this.proceWoTou();
}
}
class Consumer implements Runnable{
SynStack syn;
Consumer(SynStack syn) {
this.syn=syn;
}
public void consumerWoTou() {
for(int i=0;i<20;i++) {
WoTou wt=syn.pop();
System.out.println("消费了一个"+wt);
try {
Thread.sleep(500);
}catch(InterruptedException e) {
e.printStackTrace();
}
}
}
public void run() {
this.consumerWoTou();
}
}
public class ProcerConsumer {
public static void main(String[] args) {
SynStack syn = new SynStack(0);
Procer p = new Procer(syn);
Consumer c = new Consumer(syn);
new Thread(p).start();
new Thread(c).start();
}
}
⑸ 用JAVA编写消费者和生产者问题
似乎要用到线程和通道,好好看下那两块的内容吧,具体有什么不会的地方再把问题补充一下.要原代码的话......
怎么还不截题?叫你打败了,见清华大学出版社<<面向对象的程序设计与JAVA>>P228-P229.
public class Box
{
private int value;
private boolean available = false;
public synchronized int get()
{
while (available == false)
{
try
{
// 等待生产者写入数据
wait();
} catch (InterruptedException e)
{
// TODO: handle exception
e.printStackTrace();
}
}
available = false;
// 通知生产者数据已经被取走，可以再次写入数据
notifyAll();
return value;
}
public synchronized void put(int value)
{
while (available == true)
{
try
{
// 等待消费者取走数据
wait();
} catch (InterruptedException e)
{
// TODO: handle exception
e.printStackTrace();
}
}
this.value = value;
available = true;
// 通知消费者可以来取数据
notifyAll();
}
}
package lly;
public class Consumer extends Thread
{
private Box box;
private String name;
public Consumer(Box b, String n)
{
box = b;
name = n;
}
public void run()
{
int value = 0;
for (int i = 1; i < 6; i++)
{
value = box.get();
System.out.println("Consumer " + name + " consumed: " + value);
try
{
sleep((int) (Math.random() * 10000));
} catch (InterruptedException e)
{
// TODO: handle exception
e.printStackTrace();
}
}
}
}
package lly;
public class Procer extends Thread
{
private Box box;
private String name;
public Procer(Box b, String n)
{
box = b;
name = n;
}
public void run()
{
for (int i = 1; i < 6; i++)
{
box.put(i);
System.out.println("Procer " + name + " proced: " + i);
try
{
sleep((int) (Math.random() * 10000));
} catch (InterruptedException e)
{
// TODO: handle exception
e.printStackTrace();
}
}
}
}
package lly;
public class ProcerConsumer
{
/**
* @param args
*/
public static void main(String[] args)
{
// TODO 自动生成方法存根
Box box = new Box();
Procer p = new Procer(box, "p");
Consumer c = new Consumer(box, "c");
p.start();
c.start();
}
}
⑹ 用Java对生产者和消费者进行模拟
北信科的么
⑺ java 生产者与消费者 的简单问题
1 toString是在控制台打印对象的时候会调用的对象的方法。。比如你定义个Sx对象sx。。然后System.out.println(sx);就会先调用sx的toString方法。。将得到的String对象打印在控制台。。每个类都继承自Object。。Object类里面有个toString方法。。返回的是该对象在内存中的地址。。如果你不重写这个方法。。打印出来的东西你看不明白的。。
2 java中数据类型有基本类型（int那些）和引用类型（就是所谓的对象）。。java中数组是对象。。每个数组对象都有一个length属性。。值是这个数组的元素个数。。对象调用属性是不需要括号的。。方法才需要。。
3 kuang ss=null;就是定义一个kuang对象ss。。其初始值为null。。为null的对象在内存中什么都没有
int index=0; Wotou[] tou=new Wotou[6];这两个都不是为空的。。都有具体的初始值。。
4 Wotou wt=ss.pop();表示定义一个Wotou对象wt。。并将调用ss对象的pop方法的返回值赋值给wt对象。。具体你看下kuang 类的pop方法就知道了。。
⑻ java Thread生产者与消费者模型
你没看见有while条件吗，你看看他的执行顺序
public synchronized void push（）在
index==arrWT.length 时 wait 等待 pop() 唤醒
public synchronized WoTou pop()
在index==0 是wait 等待 push() 唤醒
开始index==0 如果pop()先执回行他会wait()
然后push()执行让答index+1
然后唤醒push唤醒pop（）接着就是无顺序执行
当index再次为0时就重复上面的过程
到那个index==arrWT.length时就会是
push等待pop唤醒了。
⑼ JAVA模拟生产者与消费者实例
class Procter extends Thread
{
Queue q;
Procter (Queue q)
{
this.q=q;
}
public void run()
{
for(int i=0;i<10;i++)
{
q.put(i);
System.out.println("procter :"+i);
}
}
}
class Consumer extends Thread
{
Queue q;
Consumer(Queue q)
{
this.q=q;
}
public void run()
{
while(true)
{
System.out.println("Consumer:"+q.get());
}
}
}
class Queue
//key
{
int value;
boolean bFull=false;
public synchronized void put(int i)
{
if(!bFull)
{
value=i;
bFull=true;
notify();//必须用在synchronized
}
try {
wait();//必须捕获异常
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public synchronized int get()
{
if(!bFull)
try
{
wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
bFull=false;
notify();
return value;
}
}
public class test //测试类
{
public static void main(String[] args)
{
Queue q=new Queue();
Procter p=new Procter(q);
Consumer c=new Consumer(q);
p.start();
c.start();
}
}