生产者消费者问题简单解决之ArrayBlockingQueue的详解与使用

ArrayBlockingQueue是一个边界缓冲对流，底层是array，他是FIFO先进先出的。新插入的数据会被插入到队列的末尾，而且总是从队头取数据。
生产者把数据插入的队列的末尾，消费者总是从队列的头部拿数据，当队列满了之后，再往队列中插入数据会造成队列的阻塞，同样，从空的队列中取数据，也是阻塞的。

有一个公平策略，我们如果希望，队列中的数据总是按照生产者生产数据的顺序，取队列中的数据，那么我们可以在构造函数中把fair参数设置为true就可以了，但是这种操作会降低吞吐量。

java.lang.Object
---java.util.AbstractCollection<E>
----java.util.AbstractQueue<E>
------java.util.concurrent.ArrayBlockingQueue<E>
从ArrayBlockingQueue的继承体系中我们可以看出，他是属于Collection集合体系的，因此它具有collection和Iterator体系的一系列方法。

对于Collection集合体系的类，方法无非就是，add、put、take、peek、poll、clear等。 
具体方法描述详见API

对于生产者消费者问题，会涉及多线程的同步问题，那ArrayBlockingQueue是如何解决多线程同步的问题呢？生产者和消费者共同使用同一个ArrayBlockingQueue，也就是同一个消息队列。生产者往队列的队尾放入数据，消费者从对头拉取数据。那多个生产者和多个消费者如果保证线程同步问题呢， 
源码这边，我们来看一个生产者生产的问题：

    public void put(E e) throws InterruptedException {
        checkNotNull(e);
        final ReentrantLock lock = this.lock;//获取当前锁
        lock.lockInterruptibly();//加锁，消费者无法操作queue
        try {
            while (count == items.length)
                notFull.await();
            enqueue(e);//入队列
        } finally {
            lock.unlock();//生产者，插入队列结束，释放锁
        }
    }

同样，消费者，消费的时候

public E poll(long timeout, TimeUnit unit) throws InterruptedException {
        long nanos = unit.toNanos(timeout);
        final ReentrantLock lock = this.lock;//获取当前锁
        lock.lockInterruptibly();//加锁，生产者无法操作queue
        try {
            while (count == 0) {
                if (nanos <= 0)
                    return null;
                nanos = notEmpty.awaitNanos(nanos);
            }
            return dequeue();//出队列
        } finally {
            lock.unlock();//消费者，拉取队列数据结束，释放锁
        }
    }

最后一个完整的demo，简单的生产者消费者问题：

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.TimeUnit;

public class ProduceConsumeDemo {
    public static void main(String[] args) {
        ArrayBlockingQueue<Cookie> arrayBlockingQueue= new ArrayBlockingQueue<Cookie>(10);//生产者和消费者共用这一个队列，队列容量为10
        Produce produce = new Produce(arrayBlockingQueue);
        produce.start();
        //一个生产者，5个消费者
        new Thread(new Consume(arrayBlockingQueue)).start();
        new Thread(new Consume(arrayBlockingQueue)).start();
        new Thread(new Consume(arrayBlockingQueue)).start();
        new Thread(new Consume(arrayBlockingQueue)).start();
        new Thread(new Consume(arrayBlockingQueue)).start();

    }
}
class Produce extends Thread{
    private static int i=0;
    private ArrayBlockingQueue<Cookie> arrayBlockingQueue;
    public Produce(ArrayBlockingQueue<Cookie> arrayBlockingQueue){
        this.arrayBlockingQueue=arrayBlockingQueue;
    }
    public void run(){
        try {
            while (i<1000) {
                arrayBlockingQueue.put(new Cookie("cookie"+i));
                if (++i%100==0){//每生产100个，休息10s
                    Thread.sleep(10000);
                }
            }
        }catch (InterruptedException e){
            System.out.println("produce queue InterruptedException");
        }
    }
}
class Consume implements Runnable{
    private ArrayBlockingQueue<Cookie> arrayBlockingQueue;
    public Consume(ArrayBlockingQueue<Cookie> arrayBlockingQueue){
        this.arrayBlockingQueue=arrayBlockingQueue;
    }
    public void run(){
        try{
            while (true){
                Cookie poll = arrayBlockingQueue.poll(5, TimeUnit.SECONDS);//如果queue为null，那么5秒之后再去队列中取数据
                if (poll!=null)
                    System.out.println(Thread.currentThread().getName()+"--consume --"+poll);

            }
        }catch (InterruptedException e){
            System.out.println("consume queue InterruptedException");
        }
    }
}
class Cookie{
    private String number;
    public Cookie(String number){
        this.number=number;
    }
    @Override
    public String toString() {
        return number+"";
    }
}
原文：https://blog.csdn.net/zhangshk_/article/details/78848784