JUC--ArrayBlockingQueue源码分析 (基于JDK1.8)

1 概述

这是一个依赖于数组实现的有界的阻塞队列，采用先进先出的规则，队列的头元素是入队最久的元素，队列的尾元素是入队时间最晚的元素。队列的大小在队列初始化的时候一旦确定了就没法进行改变，当尝试向满队列中插入数据和从空队列中获取数据都将产生阻塞。另一方面这个队列也可以保证等待线程的公平性，只需要再初始化的时候设置公平性即可，当然，默认情况下是非公平的。

2 使用示例

ArrayBlockingQueue比较典型的使用就是用于实现生产者和消费者的模式，并且这里的队列大小的固定的。下面我们来看一下使用的示例：

import java.util.concurrent.ArrayBlockingQueue;

/**
 * 演示ArrayBlockingQueue的使用
 * @author: LIUTAO
 * @Date: Created in 2018/9/27  19:36
 * @Modified By:
 */
public class ArrayBlockingQueueDemo {
    static ArrayBlockingQueue arrayBlockingQueue = new ArrayBlockingQueue(5);

    public static void main(String[] args) {

        //producer线程
        for (int i = 0; i < 10 ; i++){
            new Thread(() -> {
                try {
                    arrayBlockingQueue.put(Thread.currentThread().getName());
                    System.out.println(Thread.currentThread().getName() + "have put");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        }

        //consumer线程
        for (int i = 0; i < 10 ; i++){
            new Thread(() -> {
                try {
                    System.out.println(arrayBlockingQueue.take() + "have got");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
            try {
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

运行代码，我们可以发现生产者线程一开始就有五个线程执行完成，将数据加入了队列，而其余线程都是当消费者执行一下，然后生产者再执行。这是因为对列的容量为5，当队列被填满的时候生产生线程就只有等待。

3 类的继承关系

这里我们来看一下类的继承关系。

从这里我们可以看出ArrayBlockingQueue拥有阻塞队列的特性。

4 属性

    //存放队列的数据
    final Object[] items;

    //即将被消费的数组数据索引
    int takeIndex;

    //即将存入的数组数据的索引
    int putIndex;

    //队列中的元素个数
    int count;

    //保证线程安全的重入锁
    final ReentrantLock lock;

    //不为空的条件
    private final Condition notEmpty;

    //有空闲位置的条件
    private final Condition notFull;

从上面我们可以看出，为了保证线程的安全性和线程间的通信，这里使用了ReentrantLock和Condition。

5 构造函数

针对构造函数，这里我们仅仅查看一个比较核心的就行。

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();
    }

从上面我们可以看出构造函数其实就只做了两件事：（1）初始化数据存放数据。（2）初始化保证线程安全的重入锁。

6 核心函数

核心函数我们通过查看“JUC--队列概述” 可以知道针对阻塞队列入队和出队一共有四组函数，这里我们仅仅分析put和take函数，其余的函数逻辑大同小异。

6.1 put函数

首先直接上put函数的源码：

public void put(E e) throws InterruptedException {

        //检查e是否为空，为空则直接抛出NullPointerException
        checkNotNull(e);
        final ReentrantLock lock = this.lock;

        //加锁
        lock.lockInterruptibly();
        try {

            //当当前队列中的元素个数和数组大小相等的时候等待
            while (count == items.length)
                notFull.await();

            //数据入队
            enqueue(e);
        } finally {

            //释放锁
            lock.unlock();
        }
    }

上面的逻辑比较清晰简单，我们就直接来看一下入队是怎么操作的。

private void enqueue(E x) {
        
        //获得数据存储数组
        final Object[] items = this.items;

        //存入数据
        items[putIndex] = x;

        //当数据存入了数组的最后一个位置，为了保证FIFO规则，下一次从数组第一个位置开始存储
        if (++putIndex == items.length)
            putIndex = 0;
        count++;

        //唤醒处于等待状态的消费线程
        notEmpty.signal();
    }

上面的逻辑也比较简单，可谓充分使用了Condition，接下来我们来看一下take的实现。

6.2 take函数

同样，直接上源码：

    public E take() throws InterruptedException {
        final ReentrantLock lock = this.lock;

        //加锁，注意：这是响应中断的
        lock.lockInterruptibly();
        try {
           
            //当当前队列没有数据的时候等待
            while (count == 0)
                notEmpty.await();

            //出对
            return dequeue();
        } finally {

            //释放锁
            lock.unlock();
        }
    }

可以看出这里还是当没有数据的时候进行等待，知道put添加数据并调用notEmpty.signal()。

那么这里出对又是咋个实现的呢？

 private E dequeue() {
        
        //获取数组
        final Object[] items = this.items;
        
        //获取数据
        E x = (E) items[takeIndex];
        items[takeIndex] = null;

        //当当前获取数据的索引为数组的最后一个索引的时候，下一次从数组的首位开始获取
        if (++takeIndex == items.length)
            takeIndex = 0;
        count--;
        if (itrs != null)
            itrs.elementDequeued();

        //通知生产者线程
        notFull.signal();
        return x;
    }

总地说来，也比较简单，这里就不过多分析了。

7 总结

经过上面的分心与学习，我们了解到，其实ArrayBlockingQueue就是使用数组存储数据，然后使用ReentrantLock来保证线程的安全性，使用Condition来进行线程间的通信。接下来博主会继续分析其他的队列类的实现，欢迎关注。