生产者-消费者模式

可以用wait()和notify()来实现，也可以用阻塞队列，下面介绍阻塞队列：

阻塞队列：

BlockingQueue阻塞队列提供可阻塞的put和take方法，以及支持定时的offer和poll方法。如果队列已经满了，那么put方法将阻塞直到空间可用；如果队列为空，那么take方法将阻塞直到有元素可用。

　　队列可以是有界的也可以是无界的。

　　阻塞队列提供了一个offer方法，如果数据项不能被添加到队列中，那么将返回一个失败状态。

　　在构建高可靠的应用程序时，有界队列是一种强大的资源管理工具：它们能抵制并防止产生过多的工作项，使应用程序在负荷过载的情况下变得更加健壮。

 

BlockingQueue的多种实现： 
　　LinkedBlockingQueue和ArrayBlockingQueue：是FIFO，二者分别与LinkedList和ArrayList类似，但比同步List拥有更好的并发性能。 

　　PriorityBlockingQueue：是一个按优先级排序的队列，当你希望按照某种顺序而不是FIFO来处理元素时，这个队列将非常有用。

　　SynchronousQueue：事实上它并不是一个真正的队列，因为它不会为队列中元素维护存储空间。与其他队列不同的是，它维护一组线程，这些线程在等待这把元素加入或移出队列。 
如果以洗盘子为比喻，就相当于没有盘架来暂时存放洗好的盘子，而是将洗好的盘子直接放入下一个空闲的烘干机中。

生产者：

import java.util.concurrent.BlockingQueue;


public class Producer implements Runnable{
    
    BlockingQueue<String> queue;

    Producer(BlockingQueue<String> queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        try {
            String temp = Thread.currentThread().getName() ;
            queue.put(temp);
            System.out.println("一个产品由   " + temp + "  生产");
            //Thread.sleep(1000) ;
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
    }

}

消费者：

import java.util.concurrent.BlockingQueue;


public class Consumer implements Runnable{

    BlockingQueue<String> queue;

    Consumer(BlockingQueue<String> queue) {
        this.queue = queue;
    }
    
    @Override
    public void run() {
        try {
            String temp = queue.take() ;
            System.out.println(temp + " 生产的一个产品被   " + Thread.currentThread().getName() + "  消费");
            Thread.sleep(1000) ;
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
    }

}

测试：

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;


public class ProducerConsumerExample {
    

    public static void main(String[] args) {
        BlockingQueue<String> queue = new LinkedBlockingQueue<>(2) ;
        
        Producer p = new Producer(queue) ;
        Consumer c = new Consumer(queue) ;
        
        for(int i = 1 ; i <= 5 ; i++) {
            new Thread(p,"Producer"+i).start();
            
            new Thread(c,"Consumer"+i).start();
        }
    }

}

结果：

阻塞队列使用最经典的场景就是socket客户端数据的读取和解析，读取数据的线程不断将数据放入队列，然后解析线程不断从队列取数据解析。还有其他类似的场景，只要符合生产者-消费者模型的都可以使用阻塞队列。

实际应用中的例子：微信消息处理队列

public class WechatMsgSendJob {
    private static Log log = LogFactory.getLog(WechatMsgSendJob.class);
    private static  BlockingQueue<WechatMsg> msgs = new LinkedBlockingQueue<WechatMsg>(10000);
   
    public static void addMsg(WechatMsg msg) {
        try {
            msgs.put(msg);
        } catch (InterruptedException e) {
            log.error("addMsg error", e);
        }
    }
    //init方法
    public void init(){
        try {
//启动线程池，8个线程 不停的处理队列中的数据
ExecutorService consumerService = Executors.newFixedThreadPool(8);
        for (int i = 0; i < 8; i++) {
            consumerService.submit(new Runnable() {
            public void run() {
                while (true) {
                    try {
                        WechatMsg msg = msgs.take();
                        if (msg != null) {
                        //这里处理数据
                                        
                                        
                        }
                        } catch (Exception e) {
                            log.error("callWechatSendApi error", e);
                        }

                }
            }
            });
            }
            }catch (Exception e) {
            log.error("sendMsg error", e);
        }
    }
}