7种阻塞队列

最新推荐文章于 2021-11-15 23:22:42 发布

柯南在写代码

最新推荐文章于 2021-11-15 23:22:42 发布

阅读量419

点赞数 1

分类专栏： # 《Java并发编程的艺术 - 方腾飞》文章标签：并发编程

本文链接：https://blog.csdn.net/sinat_34344123/article/details/107655810

版权

《Java并发编程的艺术 - 方腾飞》专栏收录该内容

7 篇文章 0 订阅

订阅专栏

眼睛看到的不是你的，但你看到之后将其思想复刻后的产物便是你的。（什么是借鉴？）

序

本文抱着互相学习分享、技术积累使其慢慢沉淀的态度写作，如有错误望各位大佬同仁指正。

文中出现代码来自 jdk 1.8

队列

FIFO(先进先出)的数据结构即为队列

阻塞队列

操作会被阻塞的队列即为阻塞队列, 在java中 BlockingQueue 接口在 Queue 接口的基础上增加了两组阻塞方法, offer(e,time) put , poll(time) take()

我也来说一说Java的7个阻塞队列

有界: 在创建队列时必须或允许指定队列大小, 允许调用抛出异常的 add 方法
无界: 在创建队列时无需或不可以指定队列大小, 无限制的插入 add = offer 操作

阻塞队列的几个操作方法

	抛出异常	特殊值	阻塞	超时
插入	add(e)	offer(e)	put(e)	offer(e,time,unit)
移除	remove()	poll()	take()	poll(time,unit)
检查	element()	peek()	不可用	不可用

1. ArrayBlockingQueue[有界]

一个使用数组实现的有界阻塞队列. 创建队列时必须给定队列大小, 同时可以通过创建队列的时候设置公平访问(通过重入锁的公平访问实现)

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

元素达到队列容量上限时再入队

根据调用不同的方法, 返回不同的状态

add 方法将抛出异常

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

offer 方法将返回 false

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

put 方法将无限时阻塞

public void put(E e) throws InterruptedException {
        checkNotNull(e);
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();
        try {
            while (count == items.length)
                notFull.await();
            enqueue(e);
        } finally {
            lock.unlock();
        }
    }

offer(E e, long timeout, TimeUnit unit) 将超时阻塞

public boolean offer(E e, long timeout, TimeUnit unit)
        throws InterruptedException {

        checkNotNull(e);
        long nanos = unit.toNanos(timeout);
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();
        try {
            while (count == items.length) {
                if (nanos <= 0)
                    return false;
                nanos = notFull.awaitNanos(nanos);
            }
            enqueue(e);
            return true;
        } finally {
            lock.unlock();
        }
    }

队列为空时获取元素时

poll 方法返回空

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

take 将无限时阻塞

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

poll(long timeout, TimeUnit unit) 超时阻塞

public E poll(long timeout, TimeUnit unit) throws InterruptedException {
    long nanos = unit.toNanos(timeout);
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly();
    try {
        while (count == 0) {
            if (nanos <= 0)
                return null;
            nanos = notEmpty.awaitNanos(nanos);
        }
        return dequeue();
    } finally {
        lock.unlock();
    }
}

总结 :

数组有界队列
可加入公平策略
插入时提供了可抛出异常操作
插入元素不能为空

该队列模式适合在需要公平访问的场景下使用, 若无公平性要求该队列个人拙见不建议使用, 因操作数组和公平性原因,其吞吐量较低

2. LinkedBlockingQueue[有界]

一个使用链表实现的有界队列

public LinkedBlockingQueue(int capacity) {
    if (capacity <= 0) throw new IllegalArgumentException();
    this.capacity = capacity;
    last = head = new Node<E>(null);
}

如果不指定大小, 默认值为 int 的最大值

public LinkedBlockingQueue() {
    this(Integer.MAX_VALUE);
}

元素达到队列容量上限时再入队

队列为空时获取元素时

与 [ArrayBlockingQueue](#1. ArrayBlockingQueue[有界]) 相同

总结:

结论不指定队列大小, 默认值为 int 最大值
吞吐量要比ArrayBlockingQueue高
链表有界队列
不可加入公平策略
插入时提供了可抛出异常操作
插入元素不能为空

3. LinkedBlockingDeque[有界]

通过链表实现的一个双端阻塞队列(LikedBlockingQueue增加了队尾的操作)

该队列增加了一组队首队尾的操作方法

add -> addFirst(push)/addLast

offer -> offerFirst/offerLast

offer(time) ->offerFirst(time)/offerLast(time)

peek -> peekFirst/peekLast

poll -> pollFirst/pollLast

poll(time) -> pollFirst(time)/pollLast(time)

put -> putFrist/putLast

增加类(add/put/offer) 原方法调用与其调用相同前缀last方法操作相同

例: add = addLast ; put = putLast

获取类(peek/poll/element) 原方法调用与其调用相同前缀first方法操作相同

例: peek = peekFirst; poll = peekFirst