Java并发--ArrayBlockingQueue如何实现阻塞队列

前言

ArrayBlockingQueue是一个由数组结构组成的有界阻塞队列。同时此队列按照先进先出的原则对元素进行排序。阻塞队列与普通的队列相比较，有两个特殊的操作。一是支持阻塞的插入方法，当队列满时，队列会阻塞插入元素的线程，直到队列不是满时。二是支持阻塞的移除元素，当队列为空时，队列会阻塞移除元素的线程，直到队列非空。那ArrayBlockingQueue如何实现这两个特殊的阻塞操作。

正文

ArrayBlockingQueue中利用通知模式来实现阻塞语义。所谓通知模式，假设向队列中插入元素的线程是生产者，从队列中移除元素的线程是消费者，当生产者向满的队列中添加元素时会阻塞生产者，如果消费者从队列中移除一个元素后，会通知生产者此队列非满，生产者被激活后会向队列中插入元素。当消费者从空队列移除元素时会阻塞消费者，如果生产者向队列添加一个元素，会通知消费者此队列非空，消费者被激活后从队列中移除一个元素。在ArrayBlockingQueue中利用Condition来实现通知模式。

ArrayBlockingQueue中有两个Condition成员变量，notEmpty与notFull，分别标识队列非空与非满。代码如下。

    // 可重入锁
    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();
    }

在ArrayBlockingQueue初始化的过程中，notEmpty与notFull两个成员变量的实例就被创建出来，notEmpty与notFull配合另外一个成员变量lock即可实现等待通知模式。

从ArrayBlockingQueue添加元素和移除元素的过程中分析阻塞实现原理。

添加元素

    public void put(E e) throws InterruptedException {
        // 检查元素非空
        checkNotNull(e);
        final ReentrantLock lock = this.lock;
        // 获取锁
        lock.lockInterruptibly();
        try {
            // 如果队列已满
            while (count == items.length)
                // 阻塞当前线程
                notFull.await();
            // 队列非满则添加元素
            enqueue(e);
        } finally {
            // 释放锁
            lock.unlock();
        }
    }

当发现队列已满时，会调用notFull的await方法阻塞当前线程。notFull调用await方法之前需要获取到锁。当队列非满时，则向队列中添加元素。

    private void enqueue(E x) {
        final Object[] items = this.items;
        // 插入元素
        items[putIndex] = x;
        if (++putIndex == items.length)
            putIndex = 0;
        count++;
        // 唤醒因为notEmpty调用awit方法而阻塞的线程，通知消费者队列非空，可以从队列移除元素
        notEmpty.signal();
    }

当向队列中添加元素后，会调用notEmpty的signal方法，唤醒因为notEmpty调用awit方法而阻塞的线程，通知该线程队列非空，可以从队列移除元素。

释放元素

    public E take() throws InterruptedException {
        final ReentrantLock lock = this.lock;
        // 获取锁
        lock.lockInterruptibly();
        try {
            // 如果队列为空
            while (count == 0)
                // 阻塞当前线程
                notEmpty.await();
            // 队列非空则移除元素
            return dequeue();
        } finally {
            lock.unlock();
        }
    }

当队列为空时，调用notEmpty的await方法阻塞当前线程，notEmpty调用await方法之前需要获取到锁。当队列非空时，会从队列中移除元素。

    private E dequeue() {
        final Object[] items = this.items;
        @SuppressWarnings("unchecked")
        E x = (E) items[takeIndex];
        // 移除元素
        items[takeIndex] = null;
        if (++takeIndex == items.length)
            takeIndex = 0;
        count--;
        if (itrs != null)
            itrs.elementDequeued();
        // 唤醒因为notFull调用awit而阻塞的线程，通知生产者此队列非满，可以添加元素
        notFull.signal();
        return x;
    }

当从队列中移除元素后，调用notFull的signal方法，唤醒因为notFull调用awit而阻塞的线程，通知生产者此队列非满，可以向队列中添加元素。

总结

可以看出ArrayBlockingQueue利用notEmpty与notFull两个Conditon成员变量来实现阻塞语义。当调用Condition的awit方法会阻塞当前线程，signal方法会唤醒因awit而阻塞的线程。而notEmpty标识ArrayBlockingQueue队列非空，notFull标识队列非满。