【死磕Java并发】-----J.U.C之阻塞队列:ArrayBlockingQueue

原创 2017年07月23日 10:01:30

原文出处http://cmsblogs.com/chenssy

ArrayBlockingQueue,一个由数组实现的有界阻塞队列。该队列采用FIFO的原则对元素进行排序添加的。

ArrayBlockingQueue为有界且固定,其大小在构造时由构造函数来决定,确认之后就不能再改变了。ArrayBlockingQueue支持对等待的生产者线程和使用者线程进行排序的可选公平策略,但是在默认情况下不保证线程公平的访问,在构造时可以选择公平策略(fair = true)。公平性通常会降低吞吐量,但是减少了可变性和避免了“不平衡性”。

ArrayBlockingQueue

先看ArrayBlockingQueue的定义:

    public class ArrayBlockingQueue<E> extends AbstractQueue<E> implements BlockingQueue<E>, Serializable {
        private static final long serialVersionUID = -817911632652898426L;
        final Object[] items;
        int takeIndex;
        int putIndex;
        int count;
        // 重入锁
        final ReentrantLock lock;
        // notEmpty condition
        private final Condition notEmpty;
        // notFull condition
        private final Condition notFull;
        transient ArrayBlockingQueue.Itrs itrs;
    }

可以清楚地看到ArrayBlockingQueue继承AbstractQueue,实现BlockingQueue接口。看过java.util包源码的同学应该都认识AbstractQueue,改类在Queue接口中扮演着非常重要的作用,该类提供了对queue操作的骨干实现(具体内容移驾其源码)。BlockingQueue继承java.util.Queue为阻塞队列的核心接口,提供了在多线程环境下的出列、入列操作,作为使用者,则不需要关心队列在什么时候阻塞线程,什么时候唤醒线程,所有一切均由BlockingQueue来完成。

ArrayBlockingQueue内部使用可重入锁ReentrantLock + Condition来完成多线程环境的并发操作。

  • items,一个定长数组,维护ArrayBlockingQueue的元素
  • takeIndex,int,为ArrayBlockingQueue对首位置
  • putIndex,int,ArrayBlockingQueue对尾位置
  • count,元素个数
  • lock,锁,ArrayBlockingQueue出列入列都必须获取该锁,两个步骤公用一个锁
  • notEmpty,出列条件
  • notFull,入列条件

入队

ArrayBlockingQueue提供了诸多方法,可以将元素加入队列尾部。

  • add(E e) :将指定的元素插入到此队列的尾部(如果立即可行且不会超过该队列的容量),在成功时返回 true,如果此队列已满,则抛出 IllegalStateException
  • offer(E e) :将指定的元素插入到此队列的尾部(如果立即可行且不会超过该队列的容量),在成功时返回 true,如果此队列已满,则返回 false
  • offer(E e, long timeout, TimeUnit unit) :将指定的元素插入此队列的尾部,如果该队列已满,则在到达指定的等待时间之前等待可用的空间
  • put(E e) :将指定的元素插入此队列的尾部,如果该队列已满,则等待可用的空间

方法较多,我们就分析一个方法:add(E e):

    public boolean add(E e) {
        return super.add(e);
    }

    public boolean add(E e) {
        if (offer(e))
            return true;
        else
            throw new IllegalStateException("Queue full");
    }

add方法调用offer(E e),如果返回false,则直接抛出IllegalStateException异常。offer(E e)为ArrayBlockingQueue实现:

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

方法首先检查是否为null,然后获取lock锁。获取锁成功后,如果队列已满则直接返回false,否则调用enqueue(E e),enqueue(E e)为入列的核心方法,所有入列的方法最终都将调用该方法在队列尾部插入元素:

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

该方法就是在putIndex(对尾)为知处添加元素,最后使用notEmpty的signal()方法通知阻塞在出列的线程(如果队列为空,则进行出列操作是会阻塞)。

出队

ArrayBlockingQueue提供的出队方法如下:

  • poll() :获取并移除此队列的头,如果此队列为空,则返回 null
  • poll(long timeout, TimeUnit unit) :获取并移除此队列的头部,在指定的等待时间前等待可用的元素(如果有必要)
  • remove(Object o) :从此队列中移除指定元素的单个实例(如果存在)
  • take() :获取并移除此队列的头部,在元素变得可用之前一直等待(如果有必要)

poll()

    public E poll() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            return (count == 0) ? null : dequeue();
        } finally {
            lock.unlock();
        }
    }

如果队列为空返回null,否则调用dequeue()获取列头元素:

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

该方法主要是从列头(takeIndex 位置)取出元素,同时如果迭代器itrs不为null,则需要维护下该迭代器。最后调用notFull.signal()唤醒入列线程。

take()

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

take()与poll()存在一个区别就是count == 0 时的处理,poll()直接返回null,而take()则是在notEmpty上面等待直到被入列的线程唤醒。


欢迎扫一扫我的公众号关注 — 及时得到博客订阅哦!

–— Java成神之路: 488391811(一起走向Java成神) –—
这里写图片描述

版权声明:版权声明:转载前请留言获得作者许可,转载后标明作者 chenssy 和原文出处。原创不易,感谢您的支持

【死磕Java并发】-----J.U.C之AQS:CLH同步队列

此篇博客所有源码均来自JDK 1.8 在上篇博客【死磕Java并发】—–J.U.C之AQS:AQS简介中提到了AQS内部维护着一个FIFO队列,该队列就是CLH同步队列。CLH同步队列是一个FIFO双...
  • chenssy
  • chenssy
  • 2017年03月07日 22:11
  • 5224

【死磕Java并发】-----J.U.C之AQS:阻塞和唤醒线程

此篇博客所有源码均来自JDK 1.8 在线程获取同步状态时如果获取失败,则加入CLH同步队列,通过通过自旋的方式不断获取同步状态,但是在自旋的过程中则需要判断当前线程是否需要阻塞,其主要方法在acqu...
  • chenssy
  • chenssy
  • 2017年03月23日 21:41
  • 5251

【死磕Java并发】-----深入分析synchronized的实现原理

记得刚刚开始学习Java的时候,一遇到多线程情况就是synchronized,相对于当时的我们来说synchronized是这么的神奇而又强大,那个时候我们赋予它一个名字“同步”,也成为了我们解决多线...
  • chenssy
  • chenssy
  • 2017年02月05日 21:48
  • 16938

【死磕Java并发】-----深入分析volatile的实现原理

通过前面一章我们了解了synchronized是一个重量级的锁,虽然JVM对它做了很多优化,而下面介绍的volatile则是轻量级的synchronized。如果一个变量使用volatile,则它比使...
  • chenssy
  • chenssy
  • 2017年02月08日 17:51
  • 3307

Java阻塞队列ArrayBlockingQueue和LinkedBlockingQueue实现原理分析(还没看,先马)

转自:Java阻塞队列ArrayBlockingQueue和LinkedBlockingQueue实现原理分析Java中的阻塞队列接口BlockingQueue继承自Queue接口。BlockingQ...
  • x_i_y_u_e
  • x_i_y_u_e
  • 2016年09月12日 14:16
  • 1858

【死磕Java并发】-----J.U.C之阻塞队列:PriorityBlockingQueue

原文出处http://cmsblogs.com/ 『chenssy』 我们知道线程Thread可以调用setPriority(int newPriority)来设置优先级的,线程优先级高的线程先执行,...
  • chenssy
  • chenssy
  • 2017年07月31日 08:58
  • 5296

【死磕Java并发】-----J.U.C之阻塞队列:BlockingQueue总结

原文出处http://cmsblogs.com/ 『chenssy』 经过前面六篇博客的阐述,我想各位应该对阻塞队列BlockingQueue有了较为深入的理解,下面来一个总结,先看整个类图:Bloc...
  • chenssy
  • chenssy
  • 2017年10月04日 18:26
  • 3015

阻塞队列和ArrayBlockingQueue源码解析

什么是阻塞队列当队列中为空时,从队列总获取元素的操作将被阻塞,当队列满时,向队列中添加元素的操作将被阻塞。试图从空的阻塞队列中获取元素的线程将会被阻塞,知道其它的线程往队列中插入新的元素。同样,试图往...
  • jijianshuai
  • jijianshuai
  • 2017年04月20日 13:41
  • 189

并发理解(阻塞队列)

并发理解(阻塞队列)
  • zhaozhenzuo
  • zhaozhenzuo
  • 2014年07月04日 08:36
  • 6677

【死磕Java并发】—–J.U.C之Condition

原文出处:http://cmsblogs.com/?p=2222 在没有Lock之前,我们使用synchronized来控制同步,配合Object的wait()、notify()系列方法可以实现...
  • aa6408323
  • aa6408323
  • 2017年04月06日 21:20
  • 504
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:【死磕Java并发】-----J.U.C之阻塞队列:ArrayBlockingQueue
举报原因:
原因补充:

(最多只允许输入30个字)