文档章节

ArrayBlockQueue源码解析

o
 osc_gu9d45li
发布于 2019/04/08 09:16
字数 2463
阅读 12
收藏 0

精选30+云产品,助力企业轻松上云!>>>

清明节和朋友去被抖音带火的一个餐厅,下午两点钟取晚上的号,前面已经有十几桌了,四点半餐厅开始正式营业,等轮到我们已经近八点了。餐厅分为几个区域,只有最火的区域(在小船上)需要排号,其他区域基本上是随到随吃的,最冷清的区域几乎都没什么人。菜的价格异常的贵,味道也并不好。最后送出两张图: image.png image.png

好了,进入今天的正题,今天要讲的是ArrayBlockQueue,ArrayBlockQueue是JUC提供的线程安全的有界的阻塞队列,一看到Array,第一反应:这货肯定和数组有关,既然是数组,那自然是有界的了,我们先来看看ArrayBlockQueue的基本使用方法,然后再看看ArrayBlockQueue的源码。

ArrayBlockQueue基本使用

public static void main(String[] args) throws InterruptedException {
        ArrayBlockingQueue<Integer> arrayBlockingQueue=new ArrayBlockingQueue(5);
        arrayBlockingQueue.offer(10);
        arrayBlockingQueue.offer(50);
        arrayBlockingQueue.add(20);
        arrayBlockingQueue.add(60);
        System.out.println(arrayBlockingQueue);

        System.out.println(arrayBlockingQueue.poll());
        System.out.println(arrayBlockingQueue);

        System.out.println(arrayBlockingQueue.take());
        System.out.println(arrayBlockingQueue);

        System.out.println(arrayBlockingQueue.peek());
        System.out.println(arrayBlockingQueue);
    }

运行结果: image.png

  1. 创建了一个长度为5的ArrayBlockQueue。
  2. 用offer方法,向ArrayBlockQueue添加了两个元素,分别是10,50。
  3. 用put方法,向ArrayBlockQueue添加了两个元素,分别是20,60。
  4. 打印出ArrayBlockQueue,结果是10,50,20,60。
  5. 用poll方法,弹出ArrayBlockQueue第一个元素,并且打印出来:10。
  6. 打印出ArrayBlockQueue,结果是50,20,60。
  7. 用take方法,弹出ArrayBlockQueue第一个元素,并且打印出来:50。
  8. 打印出ArrayBlockQueue,结果是20,60。
  9. 用peek方法,弹出ArrayBlockQueue第一个元素,并且打印出来:20。
  10. 打印出ArrayBlockQueue,结果是20,60。

代码比较简单,但是你肯定会有疑问

  • offer/add(在上面的代码中没有演示)/put都是往队列里面添加元素,区别是什么?
  • poll/take/peek都是弹出队列的元素,区别是什么?
  • 底层代码是如何保证线程安全的?
  • 数据保存在哪里?

要解决上面几个疑问,最好的办法当然是看下源码,通过亲自阅读源码所产生的印象远远要比看视频,看博客,死记硬背最后的结论要深刻的多。就算真的忘记了,只要再看看源码,瞬间可以回忆起来。

ArrayBlockQueue源码解析

构造方法

ArrayBlockQueue提供了三个构造方法,如下图所示: image.png

ArrayBlockingQueue(int capacity)
    public ArrayBlockingQueue(int capacity) {
        this(capacity, false);
    }

这是最常用的构造方法,传入capacity,capacity是容量的意思,也就是ArrayBlockingQueue的最大长度,方法内部直接调用了第二个构造方法,传入的第二个参数为false。

ArrayBlockingQueue(int capacity, boolean fair)
    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();
    }

这个构造方法接受两个参数,分别是capacity和fair,fair是boolean类型的,代表是公平锁,还是非公平锁,可以看出如果我们用第一个构造方法来创建ArrayBlockingQueue的话,采用的是非公平锁,因为公平锁会损失一定的性能,在没有充足的理由的情况下,是没有必要采用公平锁的。

方法内部做了几件事情:

  1. 创建Object类型的数组,容量为capacity,并且赋值给当前类对象的items。
  2. 创建排他锁。
  3. 创建条件变量notEmpty 。
  4. 创建条件变量notFull。

至于排他锁和两个条件变量是做什么用的,看到后面就明白了。

ArrayBlockingQueue(int capacity, boolean fair,Collection<? extends E> c)
    public ArrayBlockingQueue(int capacity, boolean fair,
                              Collection<? extends E> c) {
        //调用第二个构造方法,方法内部就是初始化数组,排他锁,两个条件变量
        this(capacity, fair);

        final ReentrantLock lock = this.lock;
        lock.lock(); // 开启排他锁
        try {
            int i = 0;
            try {
                // 循环传入的集合,把集合中的元素赋值给items数组,其中i会自增
                for (E e : c) {
                    checkNotNull(e);
                    items[i++] = e;
                }
            } catch (ArrayIndexOutOfBoundsException ex) {
                throw new IllegalArgumentException();
            }
            count = i;//把i赋值给count 
            //如果i==capacity,也就是到了最大容量,把0赋值给putIndex,否则把i赋值给putIndex
            putIndex = (i == capacity) ? 0 : i;
        } finally {
            lock.unlock();//释放排他锁
        }
    }
  1. 调用第二个构造方法,方法内部就是初始化数组items,排他锁lock,以及两个条件变量。
  2. 开启排他锁。
  3. 循环传入的集合,将集合中的元素赋值给items数组,其中i会自增。
  4. 把i赋值给count。
  5. 如果i==capacity,说明到了最大的容量,就把0赋值给putIndex,否则把i赋值给putIndex。
  6. 在finally中释放排他锁。

看到这里,我们应该明白这个构造方法的作用是什么了,就是把传入的集合作为ArrayBlockingQueuede初始化数据,但是我们又会有一个新的疑问:count,putIndex 是做什么用的。

offer(E e)

    public boolean offer(E e) {
        checkNotNull(e);
        final ReentrantLock lock = this.lock;
        lock.lock();//开启排他锁
        try {
            if (count == items.length)//如果count==items.length,返回false
                return false;
            else {
                enqueue(e);//入队
                return true;//返回true
            }
        } finally {
            lock.unlock();//释放锁
        }
    }
  1. 开启排他锁。
  2. 如果count==items.length,也就是到了最大的容量,返回false。
  3. 如果count<items.length,执行入队方法,并且返回true。
  4. 释放排他锁。

看到这里,我们应该可以明白了,ArrayBlockQueue是如何保证线程安全的,还是利用了ReentrantLock排他锁,count就是用来保存数组的当前大小的。我们再来看看enqueue方法。

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

这方法比较简单,在代码里面就不写注释了,做了如下的操作:

  1. 把x赋值给items[putIndex] 。
  2. 将putIndex进行自增,如果自增后的值 == items.length,把0赋值给putIndex 。
  3. 执行count++操作。
  4. 调用条件变量notEmpty的signal方法,说明在某个地方,必定调用了notEmpty的await方法,这里就是唤醒因为调用notEmpty的await方法而被阻塞的线程。

这里就解答了一个疑问:putIndex是做什么的,就是入队元素的下标。

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

这个方法内部最终还是调用的offer方法。

put(E e)

    public void put(E e) throws InterruptedException {
        checkNotNull(e);
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();//开启响应中断的排他锁
        try {
            while (count == items.length)//如果队列满了,调用notFull的await
                notFull.await();
            enqueue(e);//入队
        } finally {
            lock.unlock();//释放排他锁
        }
    }
  1. 开启响应中断的排他锁,如果在获取锁的过程中,当前的线程被中断,会抛出异常。
  2. 如果队列满了,调用notFull的await方法,说明在某个地方,必定调用了notFull的signal方法来唤醒当前线程,这里用while循环是为了防止虚假唤醒。
  3. 执行入队操作。
  4. 释放排他锁。

可以看到put方法和 offer/add方法的区别了:

  • offer/add:如果队列满了,直接返回false。
  • put:如果队列满了,当前线程被阻塞,等待唤醒。

poll()

    public E poll() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            return (count == 0) ? null : dequeue();
        } finally {
            lock.unlock();
        }
    }
  1. 开启排他锁。
  2. 如果count==0,直接返回null,否则执行dequeue出队操作。
  3. 释放排他锁。

我们来看dequeue方法:

    private E dequeue() {
        final Object[] items = this.items;
        @SuppressWarnings("unchecked")
        E x = (E) items[takeIndex];//获得元素的值
        items[takeIndex] = null;//把null赋值给items[takeIndex] 
        if (++takeIndex == items.length)//如果takeIndex自增后的值== items.length,就把0赋值给takeIndex
            takeIndex = 0;
        count--;
        if (itrs != null)
            itrs.elementDequeued();
        notFull.signal();//唤醒因为调用notFull的await方法而被阻塞的线程
        return x;
    }
  1. 获取元素的值,takeIndex保存的是出队的下标。
  2. 把null赋值给items[takeIndex],也就是清空被弹出的元素。
  3. 如果takeIndex自增后的值== items.length,就把0赋值给takeIndex。
  4. count--。
  5. 唤醒因为调用notFull的await方法而被阻塞的线程。

这里调用了notFull的signal方法来唤醒因为调用notFull的await方法而被阻塞的线程,那到底在哪里调用了notFull的await方法呢,还记不记得在put方法中调用了notFull的await方法,我们再看看:

            while (count == items.length)
                notFull.await();

当队列满了,就调用 notFull.await()来等待,在出队操作中,又调用了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();
        }
    }
  1. 开启排他锁。
  2. 如果count==0,代表队列是空的,则调用notEmpty的await方法,用while循环是为了防止虚假唤醒。
  3. 执行出队操作。
  4. 释放排他锁。

这里调用了notEmpty的await方法,那么哪里调用了notEmpty的signal方法呢?在enqueue入队方法里。

我们可以看到take和poll的区别:

  • take:如果队列为空,会阻塞,直到被唤醒了。
  • poll: 如果队列为空,直接返回null。

peek()

    public E peek() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            return itemAt(takeIndex); 
        } finally {
            lock.unlock();
        }
    }
    final E itemAt(int i) {
        return (E) items[i];
    }
  1. 开启排他锁。
  2. 获得元素。
  3. 释放排他锁。

我们可以看到peek和poll/take的区别:

  • peek,只是获取元素,不会清空元素。
  • poll/take,获取并清空元素。

size()

    public int size() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            return count;
        } finally {
            lock.unlock();
        }
    }
  1. 开启排他锁。
  2. 返回count。
  3. 释放排他锁。

总结

至此,ArrayBlockQueue的核心源码就分析完毕了,我们来做一个总结:

  • ArrayBlockQueue有几个比较重要的字段,分别是items,保存的是队列的数据,putIndex保存的是入队的下标,takeIndex保存的是出队的下标,count用来统计队列元素的个数,lock用来保证线程的安全性,notEmpty和notFull两个条件变量实现唤醒和阻塞。
  • offer和add是一样的,其中add方法内部调用的就是offer方法,如果队列满了,直接返回false。
  • put,如果队列满了,会被阻塞。
  • peek,只是弹出元素,不会清空元素。
  • poll,弹出并清空元素,如果队列为空,直接返回null。
  • take,弹出并清空元素,如果队列为空,会被阻塞。
o
粉丝 0
博文 500
码字总数 0
作品 0
私信 提问
加载中
请先登录后再评论。
LinkedBlockingQueue源码解析

上一篇博客,我们介绍了ArrayBlockQueue,知道了它是基于数组实现的有界阻塞队列,既然有基于数组实现的,那么一定有基于链表实现的队列了,没错,当然有,这就是我们今天的主角:LinkedBlo...

osc_wa6zijqd
04/16
6
0
Java并发包小结

1、Lock Lock功能对应关键字synchrozied功能,lock和unlock方法用于加锁和释放锁。等待锁的线程加入到等待链表中,同时阻塞线程,锁释放时,从等待链表中取出等待的线程执行,取等待的线程分...

蓝天bluesky
2018/09/21
6
0
Java ThreadPoolExecutor源码笔记

概要速记 接口Excutor->接口ExutorService->抽象类AbstractExcutorService->类ThreadPoolExcutor 线程达到上限策略corePollSize->blockQueue->maxPollSize->handle blockQueue参数如果使用L......

anteoy
2019/04/11
0
0
Java多线程与并发库高级应用-可阻塞的队列

<div id="cnblogspostbody" class="blogpost-body"><p><strong>ArrayBlockQueue 可阻塞的队列</strong></p><p><strong>  > 队列包含固定长度的队列和不固定长度的队列。</strong></p><p......

osc_o9hwrm96
2018/08/01
1
0
java的concurrent包的存储类

java的concurrent包的存储类 简略的翻看一下concurrent包,一部分是通过继承AbstractQueuedSynchronizer实现(ReentrantLock、CountDownLatch、semaphore等),一部分通过lock实现(CycliBa...

GITTODO
2016/03/28
145
0

没有更多内容

加载失败,请刷新页面

加载更多

使用amoeba实现mysql读写分离

转载马士兵连老师笔记 使用amoeba实现mysql读写分离 1、什么是amoeba? Amoeba(变形虫)项目,专注 分布式数据库 proxy 开发。座落与Client、DB Server(s)之间。对客户端透明。具有负载均衡、...

兵荒马乱的青春
12分钟前
0
0
学Vue,就要学会vue JSX(二)

学习JSX,先了解一下createElement 提到JSX,不可避免的就要提到createElement,当你看完本节,你会发现,奇怪的知识又增多了。ok,我们接着上一部分继续讲。这一次的准备工作是了解createEleme...

osc_kurqu050
13分钟前
12
0
学Vue,就要学会vue JSX(三)

是时候使用JSX代替createElement了 接着上面的讲,当我们看到上面用createElement去实现组件,太麻烦了,别说工作效率提高了,就是那些嵌套可以嵌套正确就很赞了,所以我们需要用JSX去简化整...

osc_tq5hz9vv
14分钟前
5
0
protocol buffer使用

protocol buffer使用例子 protocol buffer是什么 https://developers.google.com/protocol-buffers 这是protocol buffer的官方网站,上边有详细的使用方式。 一般常见的序列和反序列方式就是...

RandomObject
15分钟前
7
0
小白的前端之路-HTMl

HTML——超文本标记语言 HTMl里面有标签,标签又分为单标签和双标签,也分为行级元素和块级元素 标签是用<>包裹起来的,而且必须要有<>,否则会直接显示在浏览器上面哦 现在介绍一下常用标签...

osc_e45irv7l
15分钟前
9
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部