用 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();  
    }  
}