线程中的生产者/消费者场景

生产者-消费者问题可以说是线程中最基础，最经典的场景了。它把并发编程中涉及到的一些常见概念都披露了出来，可以说是线程入门绕不开的场景。什么是'生产者-消费者问题'呢，通俗的定义就是：
在指定容量的容器中，同时存在两种对象对容器进行生产或者消费的动作，由于容器的容量有限，使得"生产"不能太多（太多没有意义，容器装不下），“消费”不能无限（容器中不一定含有那么多消费量）。具体详情可以参见生产者消费者问题。

在Java的线程模型中，我总结了对于这一问题的3种处理模式，可以分别比较一下。

1. 普通模式 synchronized+notify+await

这种模式应该最为普遍，不需要了解JDK1.5以后的相关线程类工具，直接使用内置关键字synchronized保证线程访问的同步性，同时使用继承至Object对象的wait，notify方法可以根据业务需求控制线程的实际访问权限。详情如下，这里业务场景是：一个盘子一次只能装一个鸡蛋，分别有放鸡蛋的线程和取鸡蛋的线程对盘子进行存取操作。

public class Plate {


    // 容器
    private List eggs = new ArrayList();


    // 取鸡蛋的业务逻辑
    public synchronized void getEgg() {
        while (eggs.size() == 0) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        Egg e = eggs.get(0);
        eggs.clear();
        System.out.println(">>>>>>>>>>get egg:" + e.getName());
        notify();
    }


    // 放鸡蛋的业务逻辑
    public synchronized void putEgg(Egg egg) {
        while (eggs.size() != 0) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        eggs.add(egg);
        System.out.println(">>>>>>>>>>put egg:" + egg.getName());
        notify();
    }

    // 生产者线程
   static class PutThread implements Runnable{

       private  Plate plate;

       PutThread(Plate plate) {
           this.plate = plate;
       }

       @Override
        public void run() {
           plate.putEgg(new Egg("egg[" + RandomUtils.nextInt(10) + "]"));
        }
    }

    //消费者线程
    static  class GetThread implements Runnable{
        private  Plate plate;

        GetThread(Plate plate) {
            this.plate = plate;
        }

        @Override
        public void run() {
               plate.getEgg();
        }
    }


    static class Egg {
        private String name;
        String getName() {
            return name;
        }
        void setName(String name) {
            this.name = name;
        }

        Egg(String name) {
            this.name = name;
        }
    }


    public static void main(String [] args){
        Plate p = new Plate();
        while(true)  {
            new Thread(new PutThread(p)).start();
            new Thread(new GetThread(p)).start();
        }

    }

}

2. 巧妙模式 Semaphore

Semaphore 是JDK5推出线程工具类之一，JDK5推出的一系列线程工具类大大简化了并发编程，覆盖了一些常见的业务场景，后面我会有篇文章单独讲讲这些工具类。
下面看看如何用Semaphore 进行生产者消费者问题的解决思路。

public class NewPlate {

    private Semaphore fullSema = new Semaphore(10); // 定义容器的最大容量条件
    private Semaphore emptySema = new Semaphore(0);// 定义容器的最小容量条件
    private Semaphore mutex = new Semaphore(1);// 这个非常重要，用来控制 消费/生产逻辑一次只有一个线程来访问，说白了就是模拟Synchronized的语义。
    
    private ArrayList