Java Interview in Action - LinkedBlockingDeque

于 2022-05-28 19:33:17 发布
阅读量150 收藏
点赞数
分类专栏： 源码 JUC 文章标签： java 开发语言 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43156556/article/details/125016512
版权

LinkedBlockingDequeue 由链表实现双端阻塞队列

可在队首和队尾分别插入和删除操作

可指定队列的容量，若不指定队列容量，默认容量为 Integer.MAX_VALUE

本文流程图

提取码：1l7t

1. LinkedBlockingDeque 使用方式

public class LinkedBlockingDequeDemo {
    public static void main(String[] args) throws InterruptedException {
        LinkedBlockingDeque<String> buffer = new LinkedBlockingDeque<>(2);
        Exchanger stack = new Exchanger(buffer);
        Producer p1 = new Producer(stack, "p1");
        Consumer c1 = new Consumer(stack, "c1");
        p1.start();
        c1.start();
        Thread.sleep(5000);
        p1.setStop(true);
    }
}

class Exchanger{
    private LinkedBlockingDeque<String> buffer;

    public Exchanger(LinkedBlockingDeque<String> buffer){
        this.buffer = buffer;
    }

    public void produce(String message) throws InterruptedException {
        buffer.put(message);
    }

    public String consume() throws InterruptedException {
        return buffer.poll(1000, TimeUnit.MILLISECONDS);
    }
}

class Producer extends Thread{
    private volatile boolean stop;

    private AtomicInteger sequence = new AtomicInteger(1);

    private Exchanger exchanger;

    public Producer(Exchanger exchanger, String name){
        super(name);
        this.exchanger = exchanger;
    }

    @Override
    public void run() {
        while(!stop){
            try {
                Thread.sleep(500);
                String message = String.valueOf((sequence.getAndIncrement()));
                this.exchanger.produce(message);
                System.out.println(Thread.currentThread().getName() + "---put---" + message);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public void setStop(boolean stop){
        this.stop = stop;
    }
}


class Consumer extends Thread{
    private volatile boolean stop;

    private Exchanger exchanger;

    public Consumer(Exchanger exchanger, String name){
        super(name);
        this.exchanger = exchanger;
    }

    @Override
    public void run() {
        try {
            Thread.sleep(1000);
            String message;
            try{
                while((message = exchanger.consume()) != null){
                    System.out.println(Thread.currentThread().getName() + "---take---" + message);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

2. LinkedBlockingDeque 属性

// 头节点
transient Node<E> first;
// 尾结点
transient Node<E> last;
// 双端队列中元素数量
private transient int count;
// 双端队列的最大容量
private final int capacity;
// 可重入锁
final ReentrantLock lock = new ReentrantLock();
// 队列非空条件
private final Condition notEmpty = lock.newCondition();
// 队列未满条件
private final Condition notFull = lock.newCondition();

3. LinkedBlockingDeque 构造器

① 无参构造：未指定 capacity ，capacity = Integer.MAX_VALUE

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

本质：调用指定 capacity = Integer.MAX_VALUE 的有参构造

② 指定容量

public LinkedBlockingDeque(int capacity) {
    if (capacity <= 0) throw new IllegalArgumentException();
    this.capacity = capacity;
}

若指定容量 capacity <= 0 抛出 IllegalArgumentException异常

③ 指定集合参数

public LinkedBlockingDeque(Collection<? extends E> c) {
    this(Integer.MAX_VALUE);
    final ReentrantLock lock = this.lock;
    lock.lock(); // Never contended, but necessary for visibility
    try {
        for (E e : c) {
            if (e == null)
                throw new NullPointerException();
            if (!linkLast(new Node<E>(e)))
                throw new IllegalStateException("Deque full");
        }
    } finally {
        lock.unlock();
    }
}

注意：该构造函数里面使用了 lock，注释部分说，加锁不是因为有竞争，是为了可见度

以集合作为参数，依次将集合元素添加到链表末尾

若集合元素为 null则抛出NullPointerException异常

若添加失败，说明队列已满，抛出IllegalStateException("Deque full")异常

4. LinkedBlockingDeque 入队

4.1 addFirst(E) && addLast(E)

addFirst(E e)

public void addFirst(E e) {
    if (!offerFirst(e))
        throw new IllegalStateException("Deque full");
}

addLast(E e) 仅需要将其中的 offerFirst(e)替换为 offerLast(e)
在这里插入图片描述
若 offerFirst(E)/offerLast(E)执行失败，返回 false，抛出 IllegalStateException异常

4.2 offerFirst(E) && offerLast(E)

offerFirst(E)

public boolean offerFirst(E e) {
    if (e == null) throw new NullPointerException();
    Node<E> node = new Node<E>(e);
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        return linkFirst(node);
    } finally {
        lock.unlock();
    }
}

在这里插入图片描述
执行流程：

① 判断添加元素E 是否为 null，若为 null 则抛出NullPointerException异常

② 将元素封装到 Node 结点中

③ ReentrantLock 加锁，调用 linkFirst(node)/linkLast(node)将node添加到链表中

④ 解锁，返回是否添加成功【添加失败的情况为：队列满】

4.2.1 linkFirst(Node) && linkLast(Node)

linkFirst(node)

private boolean linkFirst(Node<E> node) {
        // assert lock.isHeldByCurrentThread();
        if (count >= capacity)
            return false;
        Node<E> f = first;
        node.next = f;
        first = node;
        if (last == null)
            last = node;
        else
            f.prev = node;
        ++count;
        notEmpty.signal();
        return true;
    }

linkLast(node) 仅需要将上述代码中的 first—last，prev—next互换即可
在这里插入图片描述
将元素添加到链表首尾位置的执行流程：

① 判断队列是否满，满则返回 false，添加失败

② 更新首结点，尾结点

③ 判断添加前队列是否为空，为空则更新首尾结点

④ 更新队列大小

⑤ 唤醒等待 非空条件的线程

⑥ 返回操作成功

4.3 putFirst(E) && putLast(E)

putFirst(E e)

public void putFirst(E e) throws InterruptedException {
    if (e == null) throw new NullPointerException();
    Node<E> node = new Node<E>(e);
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        while (!linkFirst(node))
            notFull.await();
    } finally {
        lock.unlock();
    }
}

在这里插入图片描述
putFirst(E e) 的执行流程同 offerFirst(E e)

不同点：

① 返回值：

offerFirst(E) offerLast(E) 有 boolean 类型的返回值

putFirst(E) putLast(E) 没有返回值

② 阻塞式获取：

offerFirst(E) offerLast(E) 若队列满则返回 false

putFirst(E) putLast(E)调用notFull.await()无限期等待直到队列非满

相同点：

① 若添加元素为 null，则抛出NullPointerException异常

② 调用 linkFirst(node) linkLast(node) 添加元素

4.4 offerFirst(E, long, TimeUnit) && offerLast(E, long, TimeUnit)

offerFirst(E e, long timeout, TimeUnit unit)

public boolean offerFirst(E e, long timeout, TimeUnit unit) throws InterruptedException {
    if (e == null) throw new NullPointerException();
    Node<E> node = new Node<E>(e);
    long nanos = unit.toNanos(timeout);
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly();
    try {
        while (!linkFirst(node)) {
            if (nanos <= 0)
                return false;
            nanos = notFull.awaitNanos(nanos);
        }
        return true;
    } finally {
        lock.unlock();
    }
}

在这里插入图片描述
offerFirst(E e, long timeout, TimeUnit unit) 在 offerFirst(E e) 的基础上指定等待时间阻塞式获取

并且设置可中断获取锁：lock.lockInterruptibly()

等待指定时间获取实现流程：

① 通过 linkFirst(node) linkLast(node)判断是否添加成功

② 添加失败则判断等待是否超时，若不超时则调用notFull.awaitNanos()继续等待

③ 重复 ① ，②，直到成功添加返回true，或等待超时返回 false

5. LinkedBlockingDeque 出队

5.1 removeFirst() && removeLast()

removeFirst()

public E removeFirst() {
    E x = pollFirst();
    if (x == null) throw new NoSuchElementException();
    return x;
}

在这里插入图片描述
removeFirst() 调用 pollFirst() 返回从队首移出的值x，若x为null，则抛出NoSuchElementException异常

5.2 pollFirst() && pollLast()

pollFirst()

public E pollFirst() {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        return unlinkFirst();
    } finally {
        lock.unlock();
    }
}

在这里插入图片描述
对比前面，pollFirst() 和 offerFirst(E e) 是相对应的，出队和入队操作

非阻塞式获取，返回是否获取成功

5.2.1 unlinkFirst() && unlinkLast()

unlinkFirst()

private E unlinkFirst() {
    Node<E> f = first;
    if (f == null)
        return null;
    Node<E> n = f.next;
    E item = f.item;
    f.item = null;
    f.next = f; // help GC
    first = n;
    if (n == null)
        last = null;
    else
        n.prev = null;
    --count;
    notFull.signal();
    return item;
}

unlinkLast() 代码部分，只需要将 first – last，next – prev
在这里插入图片描述
移除链表首，尾位置上的元素执行流程：

① 判断队列是否为空，为空则返回 null

② 不为空则移除队首，队尾元素

③ 判断移除后队列是否为空，为空则更新首尾结点

④ 更新队列大小

⑤ 唤醒 等待非满条件的 存线程

⑥ 返回 取出的元素值

5.3 takeFirst() && takeLast()

takeFirst()

public E takeFirst() throws InterruptedException {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        E x;
        while ( (x = unlinkFirst()) == null)
            notEmpty.await();
        return x;
    } finally {
        lock.unlock();
    }
}

在这里插入图片描述
takeFirst() 和 putFirst(E e) 是相对应的，出队和入队操作 阻塞式获取

putFirst(E e) 若队列满，则调用notFull.await()无限期等待直到队列非满，由于一定会成功添加元素因此没有返回值

takeFirst() 若队列空，则调用notEmpty.await()无限期等待直到队列非空，一定会获取成功，并将获取到的值返回

5.4 pollFirst(E, long, TimeUnit) && pollLast(E, long, TimeUnit)

pollFirst(long timeout, TimeUnit unit)

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

在这里插入图片描述
pollFirst(long timeout, TimeUnit unit) 和 offerFirst(E e, long timeout, TimeUnit unit) 是相对应的

指定时间阻塞式获取和阻塞式添加

若等待超时：

添加失败返回false否则返回true

获取失败返回null，否则返回获取到的值

若等待未超时：调用 notFull.awaitNanos，notEmpty.awaitNanos继续阻塞式获取

6. FIFO

6.1 in

public boolean add(E e) {
    addLast(e);
    return true;
}

public boolean offer(E e) {
    return offerLast(e);
}

public void put(E e) throws InterruptedException {
    putLast(e);
}

public boolean offer(E e, long timeout, TimeUnit unit)
    throws InterruptedException {
    return offerLast(e, timeout, unit);
}

在这里插入图片描述
FIFO 添加时添加到队列的尾部

6.2 out

public E remove() {
   return removeFirst();
}

public E poll() {
    return pollFirst();
}

public E take() throws InterruptedException {
    return takeFirst();
}

public E poll(long timeout, TimeUnit unit) throws InterruptedException {
    return pollFirst(timeout, unit);
}

在这里插入图片描述
FIFO 删除时移除队列首部

执霜
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java.lang.IllegalStateException: Queue full
闫瑞锋的博客
05-21 3649
长度设置大一点 就解决了
java blockingdeque_Java并发包--LinkedBlockingDeque
weixin_30204677的博客
02-16 331
LinkedBlockingDeque介绍LinkedBlockingDeque是双向链表实现的双向并发阻塞队列。该阻塞队列同时支持FIFO和FILO两种操作方式，即可以从队列的头和尾同时操作(插入/删除)；并且，该阻塞队列是支持线程安全。此外，LinkedBlockingDeque还是可选容量的(防止过度膨胀)，即可以指定队列的容量。如果不指定，默认容量大小等于Integer.MAX_VALUE...
blockingdeque java_Java并发编程之LinkedBlockingDeque阻塞队列详解
weixin_39631953的博客
02-13 157
简介LinkedBlockingDeque是一个由链表结构组成的双向阻塞队列，即可以从队列的两端插入和移除元素。双向队列因为多了一个操作队列的入口，在多线程同时入队时，也就减少了一半的竞争。相比于其他阻塞队列，LinkedBlockingDeque多了addFirst、addLast、peekFirst、peekLast等方法，以first结尾的方法，表示插入、获取获移除双端队列的第一个元素。以l...
Java多线程--阻塞队列
BtWangZhi的博客
02-08 546
如果队列满了，添加元素的线程将会陷入等待状态，而队列为空，获取元素的线程将会陷入等待。有了BlockingQueue，我们不需要关心什么时候需要阻塞线程，什么时候需要唤醒线程。这一切都交给了BlockingQueue。 ...
JUC之BlockingDeque双端队列
爪哇岛咖啡种植农场
07-28 381
可以从队首和队尾进行元素的添加和移出的双端阻塞队列-BlockingDeque
javax.servlet.ServletException: java.lang.IllegalStateException: Queue full
kngines
04-17 4774
HTTP Status 500 - Internal Server Error java.lang.IllegalStateException: Queue full note：The full stack traces of the exception and its root causes are available in the GlassFish Server Open Source Edition 4.0 logs.
Java-Interview-Questions-and-Answers
最新发布
06-18
Java Interview Questions and Answers Java 面试题 - 初学者 中级 Java 面试题 - 有经验 (2-5 年) 高级 Java 面试题和答案 - 有经验 (5-10 年) Java 8 面试题列表
java面试java-interview-guide-master.zip
03-25
这份"java面试java_interview_guide-master.zip"资源显然是为准备Java面试而设计的，包含了丰富的Java技术知识点和面试常见问题。以下将从Java语言基础、核心特性、集合框架、多线程、网络编程、异常处理、JVM内存...
Java-Interview-Advanced-master.zip
07-18
"Java-Interview-Advanced-master.zip" 文件很可能包含了一套完整的Java高级面试准备资料，旨在帮助开发者深入理解Java的核心概念并提升在面试中的竞争力。 1. **面向对象编程**：Java是纯面向对象的，理解类、对象...
java-interview-questions-master.zip
01-15
"java-interview-questions-master.zip"这个压缩包很可能是包含了一系列Java面试常问问题和解答的资源，帮助求职者准备面试。 首先，Java基础知识是面试的起点，包括但不限于以下几点： 1. **Java语法**：熟悉基本...
Java多线程（六）之Deque与LinkedBlockingDeque深入分析
Vern的专栏
12-07 2万+
一、双向队列Deque Queue除了前面介绍的实现外，还有一种双向的Queue实现Deque。这种队列允许在队列头和尾部进行入队出队操作，因此在功能上比Queue显然要更复杂。下图描述的是Deque的完整体系图。需要说明的是LinkedList也已经加入了Deque的一部分（LinkedList是从jdk1.2 开始就存在数据结构）。   Deque在Q
高并发编程之LinkedBlockingDeque讲解
weixin_42146366的博客
02-27 9228
一、LinkedBlockingDeque介绍 LinkedBlockingDeque是双向链表实现的双向并发阻塞队列。该阻塞队列同时支持FIFO和FILO两种操作方式，即可以从队列的头和尾同时操作(插入/删除)；并且，该阻塞队列是支持线程安全。还有，LinkedBlockingDeque还是可选容量的(防止过度膨胀)，即可以指定队列的容量。如果不指定，默认容量大小等于Integer.MAX_VA...
Java并发编程之LinkedBlockingDeque阻塞队列详解
热门推荐
Stay Hungry, Stay Foolish
06-06 2万+
简介LinkedBlockingDeque是一个由链表结构组成的双向阻塞队列，即可以从队列的两端插入和移除元素。双向队列因为多了一个操作队列的入口，在多线程同时入队时，也就减少了一半的竞争。相比于其他阻塞队列，LinkedBlockingDeque多了addFirst、addLast、peekFirst、peekLast等方法，以first结尾的方法，表示插入、获取获移除双端队列的第一个元素。以l...
Java并发学习(二十三)-LinkedBlockingQueue和LinkedBlockingDeque分析
anLA_的专栏
01-10 1万+
有两个比较相似的并发阻塞队列，LinkedBlockingQueue和LinkedBlockingDeque，两个都是队列，只不过前者只能一端出一端入，后者则可以两端同时出入，并且都是结构改变线程安全的队列。其实两个队列从实现思想上比较容易理解，有以下特点： 链表结构（动态数组） 通过ReentrantLock实现锁 利用Condition实现队列的阻塞等待，唤醒 以下将分开讲述LinkedBloc
【java队列】LinkedBlockingDeque
m0_45406092的博客
09-29 392
文章目录1、简介2、源码分析2.1、属性2.2、构造函数2.3、方法2.3.1、入队方法add相关的方法offer相关的方法put相关的方法2.3.2、出队方法remove相关的方法poll相关的方法 1、简介 上一篇我们介绍了 LinkedBlockingDeque 的兄弟篇 LinkedBlockingQueue 。听名字也知道一个实现了 Queue 接口，一个实现了 Deque 接口，由于 Deque 接口又继承于 Queue ，所以 LinkedBlockingDeque 自然就有 LinkedBl
JDK8系列：阻塞队列 之 LinkedBlockingDeque（双向阻塞队列）源码解析
啦卡的博客
11-07 418
1、LinkedBlockingDeque 简介 LinkedBlockingDeque是一个基于链表的双端阻塞队列。和LinkedBlockingQueue类似，区别在于该类实现了Deque接口，而LinkedBlockingQueue实现了Queue接口。该类的继承关系如下图： 容量问题 LinkedBlockingDeque是一个可选容量的阻塞队列，如果没有设置容量，那么容量将是Int的最大值。 底层数据结构 LinkedBlockingDeque的底层数据结构是一个双端队列，该队列使用链.
7种阻塞队列
07-29 415
眼睛看到的不是你的，但你看到之后将其思想复刻后的产物便是你的。（什么是借鉴？）
深入理解阻塞队列（一）——基本结构
xingfeng_coder的博客
05-31 9238
BlockingQueue是一个继承自Queue的接口，在Queue的队列基础上增加了阻塞操作。简单来说，就是在在BlockingQueue为空时从队头取数据将会被阻塞，因为此时还没有数据可取，一旦队列中有数据了，取数据的线程就会释放得到了数据；如果BlockingQueue有容量限制且满了，那么插入数据的线程将会阻塞，知道队列中有空闲位置可以插入数据了，才会释放。经过上面一段描述，可以发现这不就是
java线程安全之并发Queue（十三）
hfbin的博客
11-19 2万+
java线程安全之并发Queue（十三）
Java面试宝典2010版
11-22
2010年出版的《Java面试宝典》是一本面向Java开发者的重要参考资料，其中涵盖了Java基础知识、面向对象编程、集合框架、多线程、IO流和数据库连接等方面的内容。在这本宝典中，作者对Java语言的一些重要问题进行了...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值