ArrayBlockingQueue－我们到底能走多远系列(42)

我们到底能走多远系列(42)

扯淡：

　　乘着有空，读些juc的源码学习下。后续把juc大致走一边，反正以后肯定要再来。

主题：

BlockingQueue 是什么

A java.util.Queue that additionally supports operations that wait for the queue to become non-empty when retrieving an element, and wait for space to become available in the queue when storing an element. 

一个能阻塞的队列在两个操作队列时的阻塞：

　　1，获取队列中元素时，队列为空，则阻塞，直到队列中有元素。

　　2，存放一个元素时，队列已满，则阻塞，直到队列中有空位置可以存放。

BlockingQueue 作为接口规定了实现的规矩。

下面是队列核心的存取操作方法的4个种类：

	Throws exception	Special value	Blocks	Times out
Insert	add(e)	offer(e)	put(e)	offer(e, time, unit)
Remove	remove()	poll()	take()	poll(time, unit)
Examine	element()	peek()	not applicable	not applicable

 

根据上面表，在队列满或空时的策略分别包含了，抛出异常，返回boolean值，阻塞线程，阻塞到超时。

为什么要这么选择，就不清楚了。我们需要注意的是除了第三种，其他方法都没有真正阻塞线程。

 

ArrayBlockingQueue：

内部用数组实现的一个queue，按照元素先进先出（FIFO）原则。初始化后，队列容量不可改变。

支持可选的公平机制，来保证阻塞的操作线程能按照顺序排列等待。默认是不公平机制。

 

源码实现：

1，使用Object[]的一个数组来存储元素

// 队列存放元素的容器
final Object[] items;

// 下一次读取或移除的位置
int takeIndex;

// 存放下一个放入元素的位置
int putIndex;

// 队列里有效元素的数量
int count;

// 所有访问的保护锁
final ReentrantLock lock;

// 等待获取的条件
private final Condition notEmpty;

// 等待放入的条件
private final Condition notFull;

2，整个队列是有一个环绕机制的，比如这时候我一直取数据，那么读取的下标会一直后移，知道数组的末尾。如果这时候制定数组的尾部后一个下标时数组的头位。如此即实现环绕的一个队列。如此实现十分精妙，可说是整个队列实现的基础机制。

如此，这个队列的容量是不可改变的。

// 指针前移
final int inc(int i) {
    return (++i == items.length) ? 0 : i;
}

// 指针后移
final int dec(int i) {
    return ((i == 0) ? items.length : i) - 1;
}

3，直接看下核心的put和take方法实现：

put

    public void put(E e) throws InterruptedException {
        checkNotNull(e);//不能放null
        final ReentrantLock lock = this.lock;//先把锁赋给final修饰的局部变量
        // 在JUC的很多类里，都会看到这种写法：把类的属性赋值给方法内的用final修饰一个变量。
        // 这是因为类的属性是存放在堆里的，方法内的变量是存放在方法栈上的，访问方法栈比访问堆要快。
        // 在这里，this.lock属性要访问两次，通过赋值给方法的局部变量，就节省了一次堆的访问。
        // 其他的类属性只访问一次就不需要这样处理了。
        lock.lockInterruptibly();//加锁
        try {
            //循环保证避免避免虚假唤醒，虚假唤醒就是此事如果有多个线程都wait，
　　　　　　　//而被同时唤醒时都会去执行下面的insert
            //如果在while循环中，那么唤醒后先判断count大小，来确定是继续wait还是insert。
            while (count == items.length)
                notFull.await();//阻塞线程
            insert(e);
        } finally {
            lock.unlock();//释放锁
        }
    }

take

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

其中使用到insert和extract方法，当然也可以看到只有持有锁的情况下才会调用这两个方法，如此这个方法的调用不需要关系是否线程安全，调用前保证线程安全：

    private void insert(E x) {
        items[putIndex] = x;// 1,存值，非常简便
        putIndex = inc(putIndex);//2,移动下标，使用inc方法
        ++count;//3,增加元素总数
        notEmpty.signal();//4,通知在非空条件上等待的读线程
    }

    private E extract() {
        final Object[] items = this.items;//先将类变量赋给方法变量，前面提过这个用处
        E x = this.<E>cast(items[takeIndex]);
        items[takeIndex] = null;
        takeIndex = inc(takeIndex);
        --count;
        notFull.signal();
        return x;
    }

操作示意图：

1，一个环的数组

2，再放一个元素：

3，取一个元素

当然ArrayBlockingQueue里还有其他方法，这里就不赘述了。有兴趣的同学可以深入继续探索。

总结：

 1，一个环的数组设计十分巧妙。

 2，将类变量赋给方法变量的编码方式

 

---------------------------------------20161202补充---------------------------------------------

ArrayBlockingQueue利用下面三个元素控制队列：

/** Main lock guarding all access */
final ReentrantLock lock;

/** Condition for waiting takes */
private final Condition notEmpty;

/** Condition for waiting puts */
private final Condition notFull;

ReentrantLock:可重入锁，在操作队列时，用来同步化。

Condition notEmpty & Condition notFull 是ReentrantLock中的。

 Lock 框架包含了对 wait 和 notify 的概括，这个概括叫作 条件（Condition）

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

比如下面的take方法，就是用Condition来实现blocking的。

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

而当有元素放入BlockingQueue时，用notEmpty.signal()方法通知阻塞在这个条件上的线程可以抢机会进入执行了

 private void enqueue(E x) {
        // assert lock.getHoldCount() == 1;
        // assert items[putIndex] == null;
        final Object[] items = this.items;
        items[putIndex] = x;
        if (++putIndex == items.length)
            putIndex = 0;
        count++;
        notEmpty.signal();
    }

以上的同步实现方式应该是很经典的实现方式。

让我们继续前行

----------------------------------------------------------------------

努力不一定成功，但不努力肯定不会成功。