Java的Deque之Deque、BlockingDeque、LinkedBlockingDeque、ArrayDeque

原创

miaowYHu 2024-06-27 14:53:25 ©著作权

文章标签 java 网络协议网络双端队列 System 文章分类 JavaScript 前端开发

©著作权归作者所有：来自51CTO博客作者miaowYHu的原创作品，请联系作者获取转载授权，否则将追究法律责任

Java 中的 Deque（双端队列）是一种具有队列和栈特性的数据结构，它允许在两端进行插入和删除操作。Deque 接口是 Java 集合框架中的一部分，它定义了双端队列的基本操作。

BlockingDeque 接口： BlockingDeque 接口是 Deque 接口的子接口，它表示一个支持阻塞操作的双端队列。它定义了一些阻塞方法，如 putFirst(), putLast(), takeFirst(), takeLast() 等，这些方法在队列满或空时会阻塞线程。

LinkedBlockingDeque 类： LinkedBlockingDeque 类是 BlockingDeque 接口的一个实现，它基于链表实现了一个无界的阻塞双端队列。它支持并发访问，并提供了阻塞的插入和删除操作。由于它是无界队列，因此可以根据需要添加任意数量的元素。

ArrayDeque 类： ArrayDeque 类是 Deque 接口的一个实现，它基于数组实现了一个双端队列。它支持并发访问，并提供了高效的插入和删除操作。ArrayDeque 是一个动态调整大小的数组，可以根据需要自动增加或缩小容量。

Deque

Java的Deque之Deque、BlockingDeque、LinkedBlockingDeque、ArrayDeque_网络

Deque 接口： Deque 接口是 Java 集合框架中双端队列的根接口。它扩展了 Queue 接口，并添加了从两端操作队列的方法，如 addFirst(), addLast(), removeFirst(), removeLast() 等。

addFirst(E e)：在双端队列的开头插入指定元素。
addLast(E e)：在双端队列的末尾插入指定元素。
removeFirst()：移除并返回双端队列的第一个元素。
removeLast()：移除并返回双端队列的最后一个元素。
getFirst()：获取双端队列的第一个元素，但不移除。
getLast()：获取双端队列的最后一个元素，但不移除。
peekFirst()：获取双端队列的第一个元素，如果队列为空则返回 null。
peekLast()：获取双端队列的最后一个元素，如果队列为空则返回 null。
…

Java的Deque之Deque、BlockingDeque、LinkedBlockingDeque、ArrayDeque_网络协议_02

Deque 接口有多个实现类，常用的有：

ArrayDeque：基于数组实现的双端队列，它是一个动态调整大小的数组，可以根据需要自动增加或缩小容量。
LinkedList：基于链表实现的双端队列，它提供了高效的插入和删除操作，但访问元素的性能较低。
LinkedBlockingDeque：基于链表实现的无界阻塞双端队列，它支持并发访问，并提供了阻塞的插入和删除操作。

import java.util.Deque;
import java.util.ArrayDeque;

public class Main {
    public static void main(String[] args) {
        Deque<Integer> deque = new ArrayDeque<>();
        deque.addFirst(1);
        deque.addLast(2);
        deque.addFirst(3);
        System.out.println(deque); // 输出 [3, 1, 2]
        
        int first = deque.removeFirst();
        System.out.println(first); // 输出 3
        
        int last = deque.removeLast();
        System.out.println(last); // 输出 2
        
        int peekFirst = deque.peekFirst();
        System.out.println(peekFirst); // 输出 1
        
        int peekLast = deque.peekLast();
        System.out.println(peekLast); // 输出 1
        
        System.out.println(deque); // 输出 [1]
    }
}

我们创建了一个 ArrayDeque 对象，并使用 addFirst() 和 addLast() 方法在双端队列的开头和末尾插入元素。然后使用 removeFirst() 和 removeLast() 方法移除元素。使用 peekFirst() 和 peekLast() 方法获取元素但不移除。最后输出双端队列的内容。

BlockingDeque

他是Java集合中的一个接口，是Deque的子接口，表示一个支持阻塞操作的双向队列。BlockingDeque 继承了 Deque 接口的所有方法，并添加了一些阻塞方法，这些方法在队列满或空时会阻塞线程，直到队列可用或有元素可用时才会继续执行。

Java的Deque之Deque、BlockingDeque、LinkedBlockingDeque、ArrayDeque_双端队列_03

putFirst(E e)：将指定元素插入到双端队列的开头，如果队列已满，则阻塞当前线程直到队列可用。
putLast(E e)：将指定元素插入到双端队列的末尾，如果队列已满，则阻塞当前线程直到队列可用。
takeFirst()：移除并返回双端队列的第一个元素，如果队列为空，则阻塞当前线程直到有元素可用。
takeLast()：移除并返回双端队列的最后一个元素，如果队列为空，则阻塞当前线程直到有元素可。
offerFirst(E e, long timeout, TimeUnit unit)：将指定元素插入到双端队列的开头，如果队列已满，则阻塞当前线程一段时间，直到超时或队列可用。
offerLast(E e, long timeout, TimeUnit unit)：将指定元素插入到双端队列的末尾，如果队列已满，则阻塞当前线程一段时间，直到超时或队列可用。
pollFirst(long timeout, TimeUnit unit)：移除并返回双端队列的第一个元素，如果队列为空，则阻塞当前线程一段时间，直到超时或有元素可用。
pollLast(long timeout, TimeUnit unit)：移除并返回双端队列的最后一个元素，如果队列为空，则阻塞当前线程一段时间，直到超时或有元素可用。

其他方法：

Java的Deque之Deque、BlockingDeque、LinkedBlockingDeque、ArrayDeque_java_04

import java.util.concurrent.BlockingDeque;
import java.util.concurrent.LinkedBlockingDeque;

public class Main {
    public static void main(String[] args) {
        BlockingDeque<Integer> blockingDeque = new LinkedBlockingDeque<>(2);
        try {
            blockingDeque.putFirst(1);
            blockingDeque.putLast(2);
            System.out.println(blockingDeque); // 输出 [1, 2]
            
            blockingDeque.putFirst(3); // 阻塞当前线程，直到队列可用
            blockingDeque.putLast(4); // 阻塞当前线程，直到队列可用
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

创建了一个容量为 2 的 LinkedBlockingDeque 对象，并使用 putFirst() 和 putLast() 方法向双端队列中插入元素。当队列已满时，putFirst() 和 putLast() 方法会阻塞当前线程，直到队列可用。

由于我们的队列容量为 2，并且已经插入了两个元素，所以在插入第三个和第四个元素时，当前线程会被阻塞，直到队列中有空间可用。

LinkedBlockingDeque

LinkedBlockingDeque是Java中的一个双向链表阻塞队列，它实现了BlockingQueue接口，可以用于实现生产者-消费者模式等多线程场景。在本篇博客中，我将详细介绍LinkedBlockingDeque的特性、用法以及示例代码。

Java的Deque之Deque、BlockingDeque、LinkedBlockingDeque、ArrayDeque_网络_05

LinkedBlockingDeque的常用方法

add(E e)：将指定元素添加到队列的尾部，如果队列已满，则抛出IllegalStateException异常。
offer(E e)：将指定元素添加到队列的尾部，如果队列已满，则返回false。
put(E e)：将指定元素添加到队列的尾部，如果队列已满，则阻塞直到队列有空间可用。
offerFirst(E e)：将指定元素添加到队列的头部，如果队列已满，则返回false。
offerLast(E e)：将指定元素添加到队列的尾部，如果队列已满，则返回false。
poll()：获取并移除队列头部的元素，如果队列为空，则返回null。
poll(long timeout, TimeUnit unit)：在指定的时间内等待，获取并移除队列头部的元素，如果超时仍未有元素可用，则返回null。
take()：获取并移除队列头部的元素，如果队列为空，则阻塞直到队列非空。
pollFirst()：获取并移除队列头部的元素，如果队列为空，则返回null。
pollLast()：获取并移除队列尾部的元素，如果队列为空，则返回null。
peek()：获取但不移除队列头部的元素，如果队列为空，则返回null。
peekFirst()：获取但不移除队列头部的元素，如果队列为空，则返回null。
peekLast()：获取但不移除队列尾部的元素，如果队列为空，则返回null。
remove(Object o)：从队列中移除指定元素，如果存在该元素则返回true，否则返回false。
contains(Object o)：判断队列是否包含指定元素，如果包含则返回true，否则返回false。

其他方法：

Java的Deque之Deque、BlockingDeque、LinkedBlockingDeque、ArrayDeque_双端队列_06

LinkedBlockingDeque的特性

双向链表结构：LinkedBlockingDeque内部采用双向链表实现，可以高效地支持在队列两端的插入和删除操作。
阻塞操作：当队列为空时，从队列中获取元素的操作会被阻塞，直到队列中有元素可用；当队列已满时，向队列中添加元素的操作也会被阻塞，直到队列有空间可用。
无界队列：LinkedBlockingDeque在构造时可以选择是否设置队列的容量限制，如果不设置容量限制，则队列大小理论上可以无限增长。

LinkedBlockingDeque的使用

创建LinkedBlockingDeque对象

LinkedBlockingDeque<String> deque = new LinkedBlockingDeque<>();

添加元素到队列

deque.add("Element 1"); // 添加元素到队列尾部
deque.offerFirst("Element 2"); // 添加元素到队列头部

获取并移除队列元素

String element = deque.poll(); // 获取并移除队列头部元素
String lastElement = deque.pollLast(); // 获取并移除队列尾部元素

获取但不移除队列元素

String peekElement = deque.peek(); // 获取但不移除队列头部元素
String peekLastElement = deque.peekLast(); // 获取但不移除队列尾部元素

阻塞操作

String element = deque.take(); // 阻塞直到队列非空，然后获取并移除队列头部元素
deque.put("Element 3"); // 阻塞直到队列有空间可用，然后添加元素到队列尾部

示例代码

下面是一个简单的生产者-消费者示例，使用LinkedBlockingDeque作为共享队列：

import java.util.concurrent.LinkedBlockingDeque;

public class ProducerConsumerExample {
    private static LinkedBlockingDeque<Integer> queue = new LinkedBlockingDeque<>();

    public static void main(String[] args) {
        Thread producer = new Thread(() -> {
            try {
                for (int i = 0; i < 10; i++) {
                    queue.put(i);
                    System.out.println("Produced: " + i);
                    Thread.sleep(1000);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        Thread consumer = new Thread(() -> {
            try {
                for (int i = 0; i < 10; i++) {
                    int num = queue.take();
                    System.out.println("Consumed: " + num);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        producer.start();
        consumer.start();
    }
}

LinkedBlockingDeque是一个功能强大的双向链表阻塞队列，适用于多线程生产者-消费者模式等场景。通过阻塞操作和双向链表结构，它能够高效地支持并发操作。在实际应用中，可以根据具体需求选择合适的队列实现来提升系统性能和可靠性。

ArrayDeque

ArrayDeque的特性

Java的Deque之Deque、BlockingDeque、LinkedBlockingDeque、ArrayDeque_java_07

数组实现：ArrayDeque内部使用数组来存储元素，可以高效地支持在队列两端的插入和删除操作。
双端队列：ArrayDeque既可以作为队列使用，也可以作为栈使用。它支持在队列的头部和尾部进行元素的插入和删除，因此可以灵活地满足不同的需求。
无界队列：ArrayDeque在构造时不需要指定容量大小，它的大小会根据实际元素的数量自动调整，理论上可以无限增长。
非线程安全：ArrayDeque不是线程安全的，如果需要在多线程环境下使用，需要进行适当的同步处理。

注意

非线程安全：ArrayDeque不是线程安全的，如果需要在多线程环境下使用，需要进行适当的同步处理。可以使用Collections.synchronizedDeque()方法创建一个线程安全的ArrayDeque。
不支持null元素：ArrayDeque不支持存储null元素，如果尝试添加null元素，会抛出NullPointerException异常。
避免频繁调整容量：ArrayDeque的内部实现是通过循环数组来存储元素，当队列的容量不足时，会自动进行扩容。在频繁添加或删除元素的场景下，可能会导致多次扩容，影响性能。如果事先能够大致估计队列的大小，可以通过构造函数ArrayDeque(int numElements)来指定初始容量，避免频繁的容量调整。
适用于频繁操作两端的场景：ArrayDeque的优势在于支持高效地在队列的两端进行插入和删除操作。如果只需要在队列的一端进行操作，建议使用LinkedList或ArrayBlockingQueue等其他队列实现。
注意栈操作的顺序：如果将ArrayDeque用作栈使用，需要注意栈操作的顺序。使用push()方法将元素添加到栈顶，使用pop()方法移除并返回栈顶元素。栈操作需要保持一致的顺序，否则可能导致元素顺序的混乱。
避免过度依赖索引操作：由于ArrayDeque是基于数组实现的，它支持通过索引来访问元素。但是，在频繁插入和删除元素的场景下，使用索引操作可能会导致性能下降。因此，在使用ArrayDeque时，应尽量避免过度依赖索引操作，而是使用队列提供的方法来操作元素。

Java的Deque之Deque、BlockingDeque、LinkedBlockingDeque、ArrayDeque_网络_08

ArrayDeque的使用

创建ArrayDeque对象

ArrayDeque<String> deque = new ArrayDeque<>();

添加元素到队列

deque.add("Element 1"); // 添加元素到队列尾部
deque.offerFirst("Element 2"); // 添加元素到队列头部

获取并移除队列元素

String element = deque.poll(); // 获取并移除队列头部元素
String lastElement = deque.pollLast(); // 获取并移除队列尾部元素

获取但不移除队列元素

String peekElement = deque.peek(); // 获取但不移除队列头部元素
String peekLastElement = deque.peekLast(); // 获取但不移除队列尾部元素

栈操作

deque.push("Element 3"); // 将元素添加到栈顶
String popElement = deque.pop(); // 移除并返回栈顶元素

示例代码

import java.util.ArrayDeque;

public class ArrayDequeExample {
    public static void main(String[] args) {
        ArrayDeque<String> queue = new ArrayDeque<>();
        queue.offer("Element 1");
        queue.offer("Element 2");

        System.out.println(queue.poll()); // 输出: Element 1

        ArrayDeque<String> stack = new ArrayDeque<>();
        stack.push("Element 3");
        stack.push("Element 4");

        System.out.println(stack.pop()); // 输出: Element 4
    }
}

ArrayDeque是一个非常实用的双端队列，可以灵活地支持队列和栈的操作。通过数组实现和双端插入和删除操作，它能够高效地满足不同场景下的需求。在实际应用中，可以根据具体需求选择合适的队列实现来提升系统性能和可靠性。

上一篇：Spring系列学习-Bean的生命周期

下一篇：Queue之Queue、BlockingQueue、AbstractQueue的相关知识介绍

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯