java线程模拟生产者消费者问题

package com.test;
import java.util.*;

/**
 * 参考文章http://www.importnew.com/16453.html
 * 学习wait() synchronized()需要搞明白两个问题
 * 1、如何正确的使用wait方法
 * 2、synchronized()是用来做什么的，哪个对象应该被synchronized
 * 3、nority()唤醒的是哪个线程，可以唤醒它自己吗？
 **/

public class ProducerConsumerInJava {

    public static void main(String args[]) { 
        System.out.println("How to use wait and notify method in Java"); 
        System.out.println("Solving Producer Consumper Problem"); 
        Queue<Integer> buffer = new LinkedList<Integer>();//创建一个长度为10的队列  模拟存储生产出的产品 
        int maxSize = 10; 
        Thread producer = new Producer(buffer, maxSize, "PRODUCER"); 
        Thread consumer = new Consumer(buffer, maxSize, "CONSUMER"); 
        producer.start();//启动生产者进程
        consumer.start(); ///启动消费者进程
        } 
    } 

    class Producer extends Thread 
    {
    /*
        * 生产者会一直生产商品到队列中供消费者使用，当队列已满，生产者调用wait()阻塞自己，当队列中已有商品的时候 ，调用notify()唤醒消费者进程
        * */
        private Queue<Integer> queue; 
        private int maxSize; 
        public Producer(Queue<Integer> queue, int maxSize, String name){ 
            super(name); this.queue = queue; this.maxSize = maxSize; 
        } 
        @Override public void run() 
        { 
            while (true) 
                { 
                    synchronized (queue) { 
                        while (queue.size() == maxSize) { 
                            try { 
                                System.out .println("Queue is full, " + "Producer thread waiting for " + "consumer to take something from queue"); 
                                queue.wait(); 
                            } catch (Exception ex) { 
                                ex.printStackTrace(); } 
                            } 
                            Random random = new Random(); 
                            int i = random.nextInt(); 
                            System.out.println("Producing value : " + i); 
                            queue.add(i); 
                            queue.notifyAll(); 
                        } 
                    } 
                } 
            } 
/*
 * 消费者消费队列中的商品 ，当队列为空时，消费者阻塞自己，唤醒生产者  记住notify()是随机唤醒等待队列中的一个线程
 * */
    class Consumer extends Thread { 
        private Queue<Integer> queue; 
        private int maxSize; 
        public Consumer(Queue<Integer> queue, int maxSize, String name){ 
            super(name); 
            this.queue = queue; 
            this.maxSize = maxSize; 
        } 
        @Override public void run() { 
            while (true) { 
                synchronized (queue) { 
                    while (queue.isEmpty()) { 
                        System.out.println("Queue is empty," + "Consumer thread is waiting" + " for producer thread to put something in queue"); 
                        try { 
                            queue.wait(); 
                        } catch (Exception ex) { 
                            ex.printStackTrace(); 
                        } 
                    } 
                    System.out.println("Consuming value : " + queue.remove()); 
                    queue.notifyAll(); 
                } 
            } 
        } 
}