用 wait-notify 解决生产者-消费者问题

//生产者
 package com.mzj.test;
 import java.util.Vector;
 import java.util.logging.Level;
 import java.util.logging.Logger;  

 public class Producer implements Runnable {  

     private final Vector sharedQueue;
     private final int SIZE;  

     public Producer(Vector sharedQueue, int size) {
         this.sharedQueue = sharedQueue;
         this.SIZE = size;
     }  

    @Override
     public void run() {
         // TODO Auto-generated method stub
         for (int i = 0; i < 7; i++) {
             System.out.println("Produced:" + i);
             try {
                 produce(i);
             } catch (InterruptedException ex) {
                 Logger.getLogger(Producer.class.getName()).log(Level.SEVERE, null, ex);
             }
         }
     }  

     private void produce(int i) throws InterruptedException {  

         //wait if queue is full
         while (sharedQueue.size() == SIZE) {
             synchronized (sharedQueue) {
                 System.out.println("Queue is full " + Thread.currentThread().getName()
                         + " is waiting , size: " + sharedQueue.size());
                 sharedQueue.wait();
             }
         }  

         //producing element and notify consumers
         synchronized (sharedQueue) {
             sharedQueue.add(i);
             sharedQueue.notifyAll();
         }
     }
 } 

消费者

 package com.mzj.test;
 import java.util.Vector;
 import java.util.logging.Level;
 import java.util.logging.Logger;  

 public class Consumer implements Runnable {  

     private final Vector sharedQueue;
     private final int SIZE;  

     public Consumer(Vector sharedQueue, int size) {
         this.sharedQueue = sharedQueue;
         this.SIZE = size;
     }  

     @Override
     public void run() {
         // TODO Auto-generated method stub
         while (true) {
             try {
                 System.out.println("Consumer: " + consume());
                 Thread.sleep(50);
             } catch (InterruptedException ex) {
                 Logger.getLogger(Consumer.class.getName()).log(Level.SEVERE, null, ex);
             }
         }
     }  

     private int consume() throws InterruptedException {  

         //wait if queue is empty
         while (sharedQueue.isEmpty()) {
             synchronized (sharedQueue) {
                 System.out.println("Queue is empty " + Thread.currentThread().getName()
                         + " is waiting , size: " + sharedQueue.size());
                 sharedQueue.wait();
             }
         }  

         //otherwise consume element and notify waiting producer
         synchronized (sharedQueue) {
             sharedQueue.notifyAll();
             return (Integer) sharedQueue.remove(0);
         }
     }
 } 

测试

 package com.mzj.test;
 import java.util.Vector;  

 public class ProducerConsumerSolution {  

     public static void main(String[] args) {
         Vector sharedQueue = new Vector();
         int size = 4;
         Thread prodThread = new Thread(new Producer(sharedQueue, size), "Producer");
         Thread consThread = new Thread(new Consumer(sharedQueue, size), "Consumer");
         prodThread.start();
         consThread.start();
     }
 }