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

 

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

 

让我们继续前行

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

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

posted on 2015-04-10 14:18  每当变幻时  阅读(1595)  评论(0编辑  收藏  举报

导航