Java并发容器——阻塞队列源码分析、生产者消费者模式、CopyOnWriteArrayList、ConcurrentLinkedQueue类总结

    Java在jdk1.6引入了并发容器阻塞队列，阻塞队列是一个统称，凡是实现了BlockingQueue接口的容器都可以称的上阻塞队列，它实现了生产者-消费者模式，在阻塞队列中出队列与入队列都有两种形式，阻塞的put与take方法以及定时获取的offer与poll方法，BlockingQueue接口源码如下：

public interface BlockingQueue<E> extends Queue<E> {
    boolean add(E e);
    boolean offer(E e);
    void put(E e) throws InterruptedException;
    boolean offer(E e, long timeout, TimeUnit unit)
        throws InterruptedException;
    E take() throws InterruptedException;
    E poll(long timeout, TimeUnit unit)
    int remainingCapacity();
    boolean remove(Object o);
    public boolean contains(Object o);
   //......
}

    主要的阻塞队列实现类如图：

    J.U.C中的并发容器用来替代Collections类中创建的同步容器，相较于同步队列，并发容器有着更好的锁粒度以及更好的在多线程环境下的并发策略，所以并发容器的并发性能都会比同步容器要好很多。

ArrayBlockingQueue

    ArrayBlockingQueue类是阻塞队列的Array实现，它是有界的，它在并发情况下的策略是持有一个ReetrantLock锁，并用Condition持有两个等待队列来实现阻塞，一个负责管理空的情况，一个负责管理满的情况：

	final ReentrantLock lock;
    private final Condition notEmpty;
    private final Condition notFull;

    之所以称它是一个有界的队列，是因为它的大小在创建时已经固定，不能改变了：

 public ArrayBlockingQueue(int capacity, boolean fair) {
        if (capacity <= 0)
            throw new IllegalArgumentException();
        this.items = new Object[capacity];
        lock = new ReentrantLock(fair);
        notEmpty = lock.newCondition();
        notFull =  lock.newCondition();
    }

    它的阻塞入队方法源码如下：

public void put(E e) throws InterruptedException {
		//检查值部位空
        checkNotNull(e);
        final ReentrantLock lock = this.lock;
        //获取全局锁
        lock.lockInterruptibly();
        try {
        	//当队列已满，调用await方法陷入等待
            while (count == items.length)
                notFull.await();
            //没有满，则入队列
            enqueue(e);
        } finally {
            lock.unlock();
        }
    }

    从源码中看出，当队列中已满的情况下，会调用await方法让当前线程陷入等待，并释放锁，只有其它线程取出了队列中的元素，并唤醒因队列满情况而陷入等待的线程，才会让元素入队列。阻塞的take出队方法与入队刚好相反，源码如下：

public E take() throws InterruptedException {
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();
        try {
            while (count == 0)
                notEmpty.await();
            return dequeue();
        } finally {
            lock.unlock();
        }
    }

    当队列为空的时候会阻塞当前线程，dequeue与enqueue方法里会调用signal方法唤醒对应的阻塞线程。还提供了一组入队以及出队的方法来灵活的处理入队以及出队：

public boolean offer(E e) {
        checkNotNull(e);
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            if (count == items.length)
                return false;
            else {
                enqueue(e);
                return true;
            }
        } finally {
            lock.unlock();
        }
    }
    
public E poll() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            return (count == 0) ? null : dequeue();
        } finally {
            lock.unlock();
        }
    }

    当队列为空或者已满的情况下，都会立马返回，而不会陷入等待，同时这两个方法还有等待时间的重载方法，当等待一定时间后，如果没有得到想要的结果，那么就会返回失败的结果。

LinkedBlockingQueue

    LinkedBlockingQueue是阻塞队列的链表实现，它在内部持有两个锁，一个入队锁，一个出队锁，并使用原子变量来记录队列的长度，它也是个有界队列：

private final ReentrantLock takeLock = new ReentrantLock();
private final Condition notEmpty = takeLock.newCondition();
private final ReentrantLock putLock = new ReentrantLock();
private final Condition notFull = putLock.newCondition();

    虽然是用链表实现的，但是在创建LinkedBlockingQueue类时，必须规定队列的大小，而且不能更改：

public LinkedBlockingQueue(int capacity) {
        if (capacity <= 0) throw new IllegalArgumentException();
        this.capacity = capacity;
        last = head = new Node<E>(null);
    }

    入队以及出队的原理与ArrayBlockingQueue类原理是一样的，但是由于入队锁以及出队锁的分离，可以实现入队和出队的同时执进行，这样就提高了性能效率。因为出队以及入队的操作并不是在同一个地方，入队在队尾操作，出队在队头进行，所以两者是影响不大的。所以一般推荐使用LinkedBlockingQueue类，因为并发效率高。

其它

    PriorityBlockingQueue类是优先级队列，如果你不想按照先进先去的方式排列，你可以使用这个类，当然进入该队列的要实现Comparable接口或者Comparator接口。

    LinkedBlockingDeque类则是双端LinkedBlockingQueue类的实现，可以在两头入队和出队操作，实现的原理是一样的。

    CopyOnWriteArrayList类与CopyOnWriteArraySet类保持同步的操作是，发布一个不变的对象，意思是说，如果有插入的操作，那么利用锁来同步重新构建一个内部数组，只要内部数组不变那么在并发的情况下访问到的数据就是正确的。但是缺点就是每次改变数据都要在内部构建一个新的数组，降低了效率，所以这两个容器适用于读操作特别多，但是写入操作很少的场景。

    ConcurrentLinkedQueue与ConcurrentLinkedDeque类内部采用CAS原子操作来保证原子性。