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

精选转载

yuantingjun 2012-10-22 14:36:18 博主文章分类：java

文章标签 java 文章分类 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();
  }
}