22.用JAVA中的多线程示例生产者和消费者问题

//22.用JAVA中的多线程示例生产者和消费者问题
//生产者生产商品，消费者取走商品，
//当商品个数为2时，停止生产，消费者可以消费；
//当商品个数为0时，停止取走, 生产者开始生产
//抽象出三个类，生产者，消费者，商品，商品有商品数量属性，和生产、消费方法
class Procedure implements Runnable{
private Shangpin shangpin;
public Procedure(Shangpin shangpin){
this.shangpin = shangpin;
}
public void run() {
System.out.println("Procedure");
shangpin.procedure();
}
}
class Consume implements Runnable{
private Shangpin shangpin;
public Consume(Shangpin shangpin){
this.shangpin = shangpin;
}
public void run() {
System.out.println("Consume");
shangpin.consume();
}
}
class Shangpin{
private int num;
private boolean flag = true;

public synchronized void consume(){

}
public synchronized void procedure(){

}
}
public class TestPro_Con {
public static void main(String[] args) {
Shangpin shangpin = new Shangpin();
new Thread(new Procedure(shangpin)).start();

new Thread(new Consume(shangpin)).start();
}

} 至此 我先搭好了一个架子，关键就是 Shangpin类的编写，他要生产商品还要消费商品，涉及到线程的很多方面的操作：生产2个时，需要暂停，0个时需要唤醒重新生产。flag用来判断是生产还是消费 package com.softeem.demo;
//22.用JAVA中的多线程示例生产者和消费者问题
//生产者生产商品，消费者取走商品，
//当商品个数为2时，停止生产，消费者可以消费；
//当商品个数为0时，停止取走, 生产者开始生产
//抽象出三个类，生产者，消费者，商品，商品有商品数量属性，和生产、消费方法
//如何实现一边生产一边消费
class Procedure implements Runnable{
private Shangpin shangpin;
public Procedure(Shangpin shangpin){
this.shangpin = shangpin;
}
public void run() {
while(true){
System.out.println("Procedure");
shangpin.procedure();
try {
Thread.sleep(1000);
} catch (InterruptedException e1) {
e1.printStackTrace();
}
}
}
}
class Consume implements Runnable{
private Shangpin shangpin;
public Consume(Shangpin shangpin){
this.shangpin = shangpin;
}
public void run() {
while(true){
System.out.println("Consume");
shangpin.consume();
try {
Thread.sleep(1000);
} catch (InterruptedException e1) {
e1.printStackTrace();
}
}
}
}
class Shangpin{
private int num;
private boolean flag = true;

public synchronized void consume(){
while(!flag){
System.out.println("消费了一个商品");
System.out.println("现在一共有： "+(--num)+" 个商品");

if(this.num <= 0){
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
flag = true;
}
}
notify();
}
public synchronized void procedure(){
while(flag){
System.out.println("生产了一个商品");
System.out.println("现在一共有： "+(++num)+" 个商品");

if(this.num >= 2){
try {
// Thread.currentThread().wait();
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
flag = false;
}
}
// Thread.currentThread().notify();
notify();

}
}
public class TestPro_Con {
public static void main(String[] args) {
Shangpin shangpin = new Shangpin();
new Thread(new Procedure(shangpin)).start();

new Thread(new Consume(shangpin)).start();
}

}

编写完成后，只能先生产两个再消费两个。。达不到要求，要能实现一边生产一边销售。
我写的可能还有问题请参考下面的程序代码：package com.softeem.demo;

class Producer implements Runnable {
private SyncStack stack;

public Producer(SyncStack stack) {
this.stack = stack;
}

public void run() {
for (int i = 0; i < stack.getProducts().length; i++) {
String product = "产品" + i;
stack.push(product);
System.out.println("生产了: " + product);
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}

}
}

}

class Consumer implements Runnable {
private SyncStack stack;

public Consumer(SyncStack stack) {
this.stack = stack;
}

public void run() {
for (int i = 0; i < stack.getProducts().length; i++) {
String product = stack.pop();
System.out.println("消费了: " + product);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}

}

}
}

class SyncStack {
private String[] products = new String[2];
private int index;

public synchronized void push(String product) {
if (index == product.length()) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
notify();
products[index] = product;
index++;
}

public synchronized String pop() {
if (index == 0) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
notify();
index--;
String product = products[index];
return product;
}

public String[] getProducts() {
return products;
}

}

public class TestProducerConsumer {

public static void main(String[] args) {
SyncStack stack = new SyncStack();
Producer p = new Producer(stack);
Consumer c = new Consumer(stack);

new Thread(p).start();
new Thread(c).start();
}
}