消费者生产者模型-java 线程模拟

   这段时间一直跟我导师做一个本科班的java课助教，每天都向对那些无聊的问题，好烦！今天终于见到他们要做一个有难度一点的题目了：
Solve a single producer, single consumer problem using wait( ) and notify( ). The producer must not overflow the receiver's buffer, which can happen if the producer is faster than the consumer. If the consumer is faster than the producer, then it must not read the same data more than once. Do not assume anything about the relative speeds of the producer or consumer.

   下面是相应的代码,关键采用了多线程,这个例子不不仅允许一个生产者和一个消费者,任意多个都可以。

 
 

  
  

   
   //
   
   产品类
   
   

   
   class
   
    Produce
{
    
   
   private
   
    String name;
    
    
   
   public
   
    Produce(String name)
    {
        
   
   this
   
   .name
   
   =
   
   name;
    }
    
    
   
   public
   
    String toString()
    {
        
   
   return
   
    name;
    }
}
  
  
 
 

 
 

  
  

   
   /**
   
    仓库类*内部采用数组来表示循环队列，以存放产品
   
   */
   
   

   
   class
   
    Storage
{

    
   
   private
   
    
   
   static
   
     
   
   int
   
    CAPACITY
   
   =
   
   11
   
   ;
    
   
   private
   
    Produce[]
    data
   
   =
   
   new
   
    Produce[CAPACITY];
    
   
   private
   
    
   
   int
   
     front
   
   =
   
   0
   
   ;
    
   
   private
   
    
   
   int
   
        rear
   
   =
   
   0
   
   ;
    
   
   public
   
    Storage(
   
   final
   
    
   
   int
   
    capacity)
    {
        
   
   this
   
   .CAPACITY
   
   =
   
   capacity
   
   +
   
   1
   
   ;
    }
    
   
   /**
   
   *消费一个产品
   
   */
   
   
    
   
   public
   
    Produce
    Consume()
   
   throws
   
    InterruptedException
    {
        
   
   synchronized
   
   (
   
   this
   
   )
        {
            
   
   while
   
   (front
   
   ==
   
   rear)
            {
                
   
   this
   
   .wait();
            }
            
   
   int
   
    access
   
   =
   
   front;
            front
   
   =
   
   (front
   
   +
   
   1
   
   +
   
   CAPACITY)
   
   %
   
   CAPACITY;
            Produce produce 
   
   =
   
   data[access];
            System.out.println(
   
   "
   
   Consumer[
   
   "
   
   +
   
    Thread.currentThread().getName()
   
   +
   
   "
   
   ] consume:
   
   "
   
   +
   
   produce);
            System.out.println(
   
   "
   
   Storage condition: count=
   
   "
   
   +
   
   (rear
   
   +
   
   CAPACITY
   
   -
   
   front) 
   
   %
   
   CAPACITY);
            
   
   this
   
   .notify();
            
   
   return
   
    produce;
        }
    }
    
   
   /**
   
   *生产一个产品
   
   */
   
   
    
   
   public
   
    
   
   void
   
    Produce(Produce produce)
   
   throws
   
    InterruptedException
    {
        
   
   synchronized
   
   (
   
   this
   
   )
        {
            
   
   while
   
   ((rear
   
   +
   
   1
   
   )
   
   %
   
   CAPACITY 
   
   ==
   
    front)
            {
                
   
   this
   
   .wait();
            }
            data[rear]
   
   =
   
   produce;                  rear
   
   =
   
   (rear
   
   +
   
   1
   
   ) 
   
   %
   
   CAPACITY;
            System.out.println(
   
   "
   
   Producer[
   
   "
   
   +
   
   Thread.currentThread().getName()
   
   +
   
   "
   
   ] produce:
   
   "
   
   +
   
    produce);
            System.out.println(
   
   "
   
   Storage condition: count=
   
   "
   
   +
   
   (rear
   
   +
   
   CAPACITY
   
   -
   
   front) 
   
   %
   
   CAPACITY);
            
   
   this
   
   .notify();
        }
    }
}

  
  
 
 

/**

*生产者类，采用线程，模拟生产者的行为

*/

class Producer extends Thread
{
	private Storage storage;
	private static int produceName=0;
   
    	public Producer(Storage storage,String name)
   	{
     		super(name);
     		this.storage=storage;
     	}
    	public void run()
    	{
     
     		while(true)
     		{
     			try
      			{
          			Produce produce=new Produce((++produceName)+"");
          			storage.Produce(produce);
         
        				sleep(100);
       			} 
       			catch(InterruptedException ie)
       			{
        				ie.printStackTrace();
        				break;
       			}
     		}
    	}
}

/**

*消费者，采用线程，模拟消费者行为

*/

class Consumer extends Thread
{
	private Storage storage;
   
    	public Consumer(Storage storage,String name)
    	{	
     		super(name);
     		this.storage=storage;
    
    	}
    	

	public void run()
    	{
    		Produce produce;
     		while(true)
     		{
     			try
       			{
      				 produce=storage.Consume();
      
       
        				 sleep(500);
       			}
      			catch(InterruptedException ie)
       			{
        				ie.printStackTrace();
        				break;
       			}
     		}
    	}
}

public class ProducerConsumer
{
	public static void main(String[] args)
	{
   		Storage storage=new Storage(10);
   		Producer producer1=new Producer(storage,"producer_01");
    		Producer producer2=new Producer(storage,"producer_02");
   		Consumer consumer1=new Consumer(storage,"consumer_01");
   		Consumer consumer2=new Consumer(storage,"consumer_02");
   		Consumer consumer3=new Consumer(storage,"consumer_03");
   		Consumer consumer4=new Consumer(storage,"consumer_04");
   		Consumer consumer5=new Consumer(storage,"consumer_05");
  		producer1.start();
   		producer2.start();
   		consumer1.start();
   		consumer2.start();
   		consumer3.start();
   		consumer4.start();
   		consumer5.start();
 	}
}