线程通信机制（生产者与消费者示例）

package org.jaychang.corejava.review;

import java.util.LinkedList;
import java.util.List;

/**
* @title <p>生产者与消费者</p>
* @author Jay Chang
* @date 2009/11/09
*/
class Stack {
private List<Object> list = new LinkedList<Object>();

/**
* 出栈
*
* @return
*/
public Object pop() {
   return list.remove(list.size() - 1);
}

/**
* 将元素压入栈
*
* @param obj
*/
public void push(Object obj) {
   list.add(list.size(), obj);
}

public int size() {
   return list.size();
}
}

/**
*
* @author Jay Chang
*
*/
class Producer extends Thread {
private Stack stack;

public Stack getStack() {
   return stack;
}

/**
*
* @param stack
*/
public void setStack(Stack stack) {
   this.stack = stack;
}

/**
* 生产者生产商品，当商品栈满时，通知消费者消费商品
*/
public void produce() {
   for (int i = 0; i < 100; i++) {
    // 同步stack
    synchronized (stack) {
     System.out.println("producer get the lock");

//这里指定存放商品的商品栈的最大容量为10

     while (stack.size() == 10) {
      try {
       //将生产者线程持有stack对象的锁释放，并将生产者线程放到stack对象的等待池中
       stack.wait();
      } catch (InterruptedException e) {
       e.printStackTrace();
      }
     }
     // 模拟生产者生产商品过程所需的时间
     try {
      Thread.sleep(1000);
     } catch (InterruptedException e) {
      e.printStackTrace();
     }
     String goods = "goods" + stack.size();

     //将生产的商品放到存放商品的商品栈中
     stack.push(goods);
     System.out.println("producer product " + goods);
     //唤醒在stack对象等待池中的等待的所有线程
     stack.notifyAll();
    }

   }
}

public void run() {
   produce();
}
}

class Consumer extends Thread {
private Stack stack;

public Stack getStack() {
   return stack;
}

public void setStack(Stack stack) {
   this.stack = stack;
}

/**
*
* 消费者消费商品,当商品栈中为空时通知生产者生产商品
*/
public void consume() {
   for (int i = 0; i < 100; i++) {
    synchronized (stack) {
     System.out.println("consumer get the lock");
     while (stack.size() == 0) {
      try {
       stack.wait();
      } catch (InterruptedException e) {
       // TODO Auto-generated catch block
       e.printStackTrace();
      }
     }
     // 模拟消费者消费商品，所需的时间
     try {
      Thread.sleep(1000);
     } catch (InterruptedException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
     }
     Object obj = stack.pop();
     System.out.println("cosumer consume " + obj);
    }
   }
}

public void run() {
   consume();
}

}

public class Test{
public static void main(String[] args) {
   Stack stack = new Stack();
   Consumer consumer = new Consumer();
   consumer.setStack(stack);
   Producer producer1 = new Producer();
   producer1.setStack(stack);
   Producer producer2 = new Producer();
   producer2.setStack(stack);
   consumer.start();producer1.start();producer2.start();

}
}

评论

3 楼 jaychang 2011-02-25  

缓冲区是一个共享资源，必须互斥访问的

2 楼 julydave 2011-02-12  

julydave 写道

From 百度知道：首先谢谢您的提示，我这个是没有对缓冲区直接设锁，看了您的例子，您那个是直接对栈设置锁了，但我觉得我这个更符合实际情况吧，我在synchronized(this)处是对生产者或者消费者单独设锁，生产者和消费者不互斥，还有就是wait那个循环，这也都是仿照《Thinking in Java 4th Edition》中的例子，我知道生产者和消费者还有很多各种各样的实现，但我现在迫切知道我这个实现的错误在什么地方，为什么wait没有把第9个线程锁住。

http://zhidao.baidu.com/question/224475092.html

1 楼 julydave 2011-02-12  

From 百度知道：首先谢谢您的提示，我这个是没有对缓冲区直接设锁，看了您的例子，您那个是直接对栈设置锁了，但我觉得我这个更符合实际情况吧，我在synchronized(this)处是对生产者或者消费者单独设锁，生产者和消费者不互斥，还有就是wait那个循环，这也都是仿照《Thinking in Java 4th Edition》中的例子，我知道生产者和消费者还有很多各种各样的实现，但我现在迫切知道我这个实现的错误在什么地方，为什么wait没有把第9个线程锁住。