synctest.txt

用java实现生产者和消费者的多线程协调问题

//生产者和消费者问题
//SyncTest.java
class SyncStack
{ //同步堆栈类
 private int index = 0; //堆栈指针初始值为0
 private char[] buffer = new char[6]; //堆栈有6个字符的空间
 public synchronized void push(char c)
 {  //加上互斥锁
  while(index==buffer.length){ //堆栈已满，不能压栈
   try{
     this.wait();  //等待，直到有数据出栈
    }catch(InterruptedException e){}
  }
  this.notify();      //通知其它线程把数据出栈
  buffer[index] = c;  //数据入栈
  index++;            //指针向上移动
 }
 public synchronized char pop()
 {  //加上互斥锁
  while(index==0){  //堆栈无数据，不能出栈
   try{
     this.wait();  //等待其它线程把数据入栈
   }catch(InterruptedException e){}
  }
  this.notify();    //通知其它线程把数据入栈
  index--;          //指针向下移动
  return buffer[index];  //数据出栈
 }
}
class Producer implements Runnable
{ //生产者类
 SyncStack theStack;
 //生产者类生成的字母都保存到同步堆栈中
 public Producer(SyncStack s)
 {
  theStack = s;
 }
 public void run()
 {
  char c;
  for(int i=0;i<20;i++){
   c = (char)(Math.random()*26+'A'); //随机产生20个字符
   theStack.push(c);                 //把字符入栈
   System.out.println("Producer:"+c);//打印字符
   try{ //每产生一个字符线程就睡眠
     Thread.sleep((int)(Math.random()*1000));
    }catch(InterruptedException e){}
  }
 }
}
class Consumer implements Runnable
{ //消费者类
 SyncStack theStack;
 //消费者类获得的字符都来自同步堆栈
 public Consumer(SyncStack s)
 {
  theStack = s;
 }
 public void run()
 {
  char c;
  for(int i=0;i<20;i++){
   c = theStack.pop();                //从栈中读取字符
   System.out.println("Consumer:"+c); //打印字符
   try{ //每读取一个字符线程就睡眠
     Thread.sleep((int)(Math.random()*1000));
    }catch(InterruptedException e){}
  }
 }
}
public class SyncTest
{
 public static void main(String[] args)
 {
  SyncStack s = new SyncStack();
  //消费者类对象和生产者类对象所操作的是同一个同步堆栈对象
  Runnable source = new Producer(s);
  Runnable sink = new Consumer(s);
  Thread t1 = new Thread(source); //线程实例化
  Thread t2 = new Thread(sink);   //线程实例化
  t1.start();  //线程启动
  t2.start();  //线程启动
 }
}