线程学习三：生产者/消费者模式

原理：

　　生产者/消费者模式就是将生产和消费分成多个线程，他们并用一个仓库。当仓库满的时候不能再生产，只能等消费了以后才能继续生产；当仓库空的时候不能再消费，必须等到生产了之后才能消费。

　　这个实现的手段有三种：使用wait() / notify()方法；使用await() / signal()方法；使用BlockingQueue阻塞队列方法

实现：

　　一、使用wait() / notify()方法

　　wait() / nofity()方法是基类Object的两个方法，也就意味着所有Java类都会拥有这两个方法，这样，我们就可以为任何对象实现同步机制。

　　wait()方法：当缓冲区已满/空时，生产者/消费者线程停止自己的执行，放弃锁，使自己处于等等状态，让其他线程执行。

　　notify()方法：当生产者/消费者向缓冲区放入/取出一个产品时，向其他等待的线程发出可执行的通知，同时放弃锁，使自己处于等待状态。

public class ProConTest {
    public final int MAX_SIZE = 10;
    public LinkedList<Object> list = new LinkedList<Object>();

    public static void main(String[] args) {
        ProConTest pct = new ProConTest();
        Producer producer = pct.new Producer();
        Consumer consumer = pct.new Consumer();
        producer.start();
        consumer.start();
    }

    class Producer extends Thread {

        @Override
        public void run() {
            Producer();
        }

        public void Producer() {
            while (true) {
                synchronized (list) {
                    if (list.size() == MAX_SIZE) {
                        System.out.println("已经满仓，不能再生产了");
                        try {
                            list.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    list.add(1);
                    System.out.println("现在仓库剩余" + list.size());
                    list.notifyAll();
                }
            }
        }
    }

    class Consumer extends Thread {

        @Override
        public void run() {
            Consumer();
        }

        public void Consumer() {
            while (true) {
                synchronized (list) {
                    if (list.size() == 0) {
                        System.out.println("仓库已经卖完，不能再消费了");
                        try {
                            list.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    list.remove();
                    System.out.println("现在仓库剩余" + list.size());
                    list.notifyAll();
                }
            }
        }
    }

}

　　二、使用await() / signal()方法

　　在JDK5.0之后，Java提供了更加健壮的线程处理机制，包括同步、锁定、线程池等，它们可以实现更细粒度的线程控制。await()和signal()就是其中用来做同步的两种方法，它们的功能基本上和wait() / nofity()相同，完全可以取代它们，但是它们和新引入的锁定机制Lock直接挂钩，具有更大的灵活性。通过在Lock对象上调用newCondition()方法，将条件变量和一个锁对象进行绑定，进而控制并发程序访问竞争资源的安全。

public class ProConTest2 {
    public final int MAX_SIZE = 10;
    public LinkedList<Object> list = new LinkedList<Object>();
    private final Lock lock = new ReentrantLock();
    private final Condition full = lock.newCondition();
    private final Condition empty = lock.newCondition();

    public static void main(String[] args) {
        ProConTest2 pct = new ProConTest2();
        Producer producer = pct.new Producer();
        Consumer consumer = pct.new Consumer();
        producer.start();
        consumer.start();
    }

    class Producer extends Thread {

        @Override
        public void run() {
            Producer();
        }

        public void Producer() {
            while (true) {
                lock.lock();
                if (list.size() == MAX_SIZE) {
                    System.out.println("已经满仓，不能再生产了");
                    try {
                        full.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                list.add(1);
                System.out.println("现在仓库剩余" + list.size());
                full.signalAll();
                empty.signalAll();
                lock.unlock();

            }
        }
    }

    class Consumer extends Thread {

        @Override
        public void run() {
            Consumer();
        }

        public void Consumer() {
            while (true) {
                lock.lock();
                if (list.size() == 0) {
                    System.out.println("仓库已经卖完，不能再消费了");
                    try {
                        empty.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                list.remove();
                System.out.println("现在仓库剩余" + list.size());
                full.signalAll();
                empty.signalAll();
                lock.unlock();

            }
        }
    }
}

　　三、使用BlockingQueue阻塞队列方法

　　BlockingQueue是JDK5.0的新增内容，它是一个已经在内部实现了同步的队列，实现方式采用的是我们第2种await() / signal()方法。它可以在生成对象时指定容量大小。它用于阻塞操作的是put()和take()方法。

　　put()方法：类似于我们上面的生产者线程，容量达到最大时，自动阻塞。

　　take()方法：类似于我们上面的消费者线程，容量为0时，自动阻塞。

public class ProConTest3 {
    public final int MAX_SIZE = 10;
    private LinkedBlockingQueue<Integer> queue = new LinkedBlockingQueue<Integer>(MAX_SIZE);

    public static void main(String[] args) {
        ProConTest3 pct = new ProConTest3();
        Producer producer = pct.new Producer();
        Consumer consumer = pct.new Consumer();
        producer.start();
        consumer.start();
    }

    class Producer extends Thread {

        @Override
        public void run() {
            Producer();
        }

        public void Producer() {
            while (true) {
                if (queue.size() == MAX_SIZE) {
                    System.out.println("已经满仓，不能再生产了");
                }
                try {
                    queue.put(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("现在仓库剩余" + queue.size());
            }
        }
    }

    class Consumer extends Thread {

        @Override
        public void run() {
            Consumer();
        }

        public void Consumer() {
            while (true) {                
                if (queue.size() == 0) {
                    System.out.println("仓库已经卖完，不能再消费了");
                }
                try {
                    queue.take();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("现在仓库剩余" + queue.size());
            }
        }
    }

}

参考

JAVA编程思想

http://blog.csdn.net/monkey_d_meng/article/details/6251879