Java 入门指南：Java 并发编程 —— 并发容器 BlockingDeque、LinkedBlockingDeque

BlockingQueue

BlockingQueue 是Java并发包（java.util.concurrent）中提供的一个阻塞队列接口，它继承自 Queue 接口。

BlockingQueue 中的元素采用 FIFO 的原则，支持多线程环境并发访问，提供了阻塞读取和写入的操作，当前线程在队列满或空的情况下会被阻塞，直到被唤醒或超时。

常用的实现类有 ArrayBlockingQueue、LinkedBlockingQueue、PriorityBlockingQueue、SynchronousQueue 等，它们的实现方式各有不同。

适用场景

BlockingQueue 通常用于一个线程生产对象，而另外一个线程消费这些对象的场景。

一个线程将会持续生产新对象并将其插入到队列之中，直到队列达到它所能容纳的临界点。

如果该阻塞队列到达了其临界点，生产者线程将会在往里边插入新对象时发生阻塞。它会一直处于阻塞之中，直到消费者线程从队列中拿走一个对象。

消费者线程将会一直从该阻塞队列中拿出对象。如果消费线程尝试去从一个空的队列中提取对象的话，这个消费线程将会处于阻塞之中，直到一个生产线程把一个对象丢进队列。

常用方法

1. put(E e)：将元素 e 插入到队列中，如果队列已满，则会阻塞当前线程，直到队列有空闲空间

2. offer(E e)：将元素 e 插入到队列中，如果队列已满，则返回 false。

3. offer(E element, long timeout, TimeUnit unit) 方法是 BlockingQueue：在指定的时间内将元素添加到队列中。

   • timeout：超时时间，表示在指定的时间内等待队列空间可用。如果超过指定的时间仍然无法将元素添加到队列中，将返回 false。

   • unit：超时时间的单位。

4. take()：移除并返回队列头部的元素，如果队列为空，则会阻塞当前线程，直到队列有元素

5. poll()：移除并返回队列头部的元素，如果队列为空，则返回 null

6. poll(long timeout, TimeUnit unit)：在指定的时间内从队列中检索并移除元素。返回移除的元素。如果超过指定的时间仍然没有可用的元素，将返回 null。

7. peek()：返回队列头部的元素，但不会移除。如果队列为空，则返回null

8. size()：返回队列中元素的数量

9. isEmpty()：判断队列是否为空，为空返回 true，否则返回 false

10. isFull()：判断队列是否已满，已满返回 true，否则返回 false

11. clear()：清空队列中的所有元素

行为	抛异常	返回特定值	阻塞	超时
插入	add(o)	offer(o)	put(o)	offer(o, timeout, timeunit)
移除	remove()	poll()	take()	poll(timeout, timeunit)
检查	element()	peek()

• 抛异常: 如果试图的操作无法立即执行，抛一个异常。

• 特定值: 如果试图的操作无法立即执行，返回 true / false / null)。

• 阻塞: 如果试图的操作无法立即执行，该方法调用将会发生阻塞，直到能够执行。

• 超时: 如果试图的操作无法立即执行，该方法调用将会发生阻塞，直到能够执行，但等待时间不会超过给定值。返回一个特定值以告知该操作是否成功(典型的是 true / false)。

若向 BlockingQueue 中插入 null，将会抛出 NullPointerException

死锁问题

需要注意的是，在使用 BlockingQueue 时要注意防止死锁的问题：

• 在队列满之后调用 offer() 方法插入元素会返回false，此时不能直接调用put()方法，因为在插入之前还需要获取其它资源，如果在获取资源时一直阻塞在这里，就会发生死锁。

• 为了防止死锁的问题，建议使用 offer(E e, long timeout, TimeUnit unit) 和 poll(long timeout, TimeUnit unit) 带有超时时间的方法。

BlockingDeque

JUC 包里的 BlockingDeque 接口表示一个线程安放入和提取实例的双端队列，继承自 BlockingQueue。

BlockingDeque 类是一个双端队列，在不能够插入元素时，它将阻塞住试图插入元素的线程；在不能够提取元素时，它将阻塞住试图提取的线程。

BlockingDeque 适用于在线程中一个队列既充当生产者又充当消费者的情况。

如果生产者线程需要在队列的两端都可以插入数据，消费者线程需要在队列的两端都可以移除数据，这个时候也可以使用 BlockingDeque。

主要方法

1. addFirst(E element)：将指定的元素插入到双端队列的头部。如果插入操作成功，则将返回 true；否则，将抛出异常。

2. addLast(E element)：将指定的元素插入到双端队列的尾部。如果插入操作成功，则将返回 true；否则，将抛出异常。

3. offerFirst(E element)：将指定的元素插入到双端队列的头部。如果插入操作成功，则将返回 true；否则，将返回 false。

4. offerLast(E element)：将指定的元素插入到双端队列的尾部。如果插入操作成功，则将返回 true；否则，将返回 false。

5. removeFirst()：移除并返回双端队列的头部元素。如果队列为空，则将抛出异常。

6. removeLast()：移除并返回双端队列的尾部元素。如果队列为空，则将抛出异常。

7. pollFirst()：移除并返回双端队列的头部元素。如果队列为空，则返回 null。

8. pollLast()：移除并返回双端队列的尾部元素。如果队列为空，则返回 null。

9. getFirst()：返回双端队列的头部元素，但不会移除它。如果队列为空，则将抛出异常。

10. getLast()：返回双端队列的尾部元素，但不会移除它。如果队列为空，则将抛出异常。

11. peekFirst()：返回双端队列的头部元素，但不会移除它。如果队列为空，则返回 null。

12. peekLast()：返回双端队列的尾部元素，但不会移除它。如果队列为空，则返回 null。

13. putFirst(E element): 将元素插入双端队列的头部，如果队列已满则阻塞等待空间可用。

14. putLast(E element): 将元素插入双端队列的尾部，如果队列已满则阻塞等待空间可用。

15. takeFirst(): 移除并返回双端队列的头部元素，如果队列为空则阻塞等待元素可用。

16. takeLast(): 移除并返回双端队列的尾部元素，如果队列为空则阻塞等待元素可用。

LinkedBlockingDeque

LinkedBlockingDeque 是 Java 中的一个具体实现类，它是一个由链表结构组成的双向阻塞队列。它继承自 AbstractQueue 类并实现了 BlockingDeque 接口。

特点

1. 链表结构：LinkedBlockingDeque 内部使用链表来存储元素，因此它的大小可以根据需要动态扩容。

2. 容量可选：可以选择初始化 LinkedBlockingDeque 时指定容量大小，如果不指定，则默认为 Integer.MAX_VALUE。当元素数量达到容量上限时，后续插入操作将会被阻塞，直到有其他线程对队列进行取出操作。

3. 双端队列：LinkedBlockingDeque 具有双端插入和双端取出的特性，即既可以在队首插入和取出元素，也可以在队尾插入和取出元素。

4. 阻塞操作：当调用插入操作（如 addFirst(), addLast(), putFirst(), putLast()) 或取出操作（如 takeFirst(), takeLast(), pollFirst(), pollLast()) 时，如果队列已满或为空，线程将会被阻塞，直到有其他线程进行相应的取出或插入操作。

5. 非线程安全：LinkedBlockingDeque 不是线程安全的，如果在多个线程中同时进行插入、取出操作，需要进行外部同步控制或使用 JUC 包中的相关线程安全类。

构造方法

1. 创建一个没有指定容量的 LinkedBlockingDeque 对象。该队列可以根据需要动态调整大小。

LinkedBlockingDeque()

2. 创建一个具有指定容量的 LinkedBlockingDeque 对象。该队列的容量是固定的，不能更改。

LinkedBlockingDeque(int capacity)

3. 创建一个具有初始元素集合的 LinkedBlockingDeque 对象。初始元素集合会按照集合的迭代器顺序依次添加到队列中，容量大小为元素个数。

LinkedBlockingDeque(Collection<? extends E> collection)

LinkedBlockingDeque 使用示例

下面是一个简单的示例，展示如何使用 LinkedBlockingDeque：

import java.util.concurrent.LinkedBlockingDeque;

public class BlockingDequeExample {

    public static void main(String[] args) throws InterruptedException {
        // 创建一个 LinkedBlockingDeque 实例
        LinkedBlockingDeque<String> deque = new LinkedBlockingDeque<>(10);

        // 向队列中添加元素
        deque.offerFirst("one");
        deque.offerLast("two");

        // 输出队列内容
        System.out.println("Initial Deque: " + deque);

        // 从队列中移除元素
        String firstElement = deque.pollFirst();
        String lastElement = deque.pollLast();

        // 输出移除后的队列内容
        System.out.println("Deque after removal: " + deque);

        // 检查队列中的元素
        System.out.println("First element: " + firstElement);
        System.out.println("Last element: " + lastElement);

        // 使用阻塞方法添加元素
        deque.putFirst("three");
        deque.putLast("four");

        // 输出添加后的队列内容
        System.out.println("Deque after adding elements: " + deque);

        // 使用阻塞方法移除元素
        String blockedFirstElement = deque.takeFirst();
        String blockedLastElement = deque.takeLast();

        // 输出移除后的队列内容
        System.out.println("Deque after blocked removal: " + deque);

        // 检查阻塞移除的元素
        System.out.println("Blocked First element: " + blockedFirstElement);
        System.out.println("Blocked Last element: " + blockedLastElement);
    }
}