Java并发编程 - JUC阻塞队列（LinkedBlockingQueue、LinkedBlockingDeque）

Java 并发编程中，java.util.concurrent（简称 JUC）包提供了多种阻塞队列 (BlockingQueue) 实现，包括 LinkedBlockingQueue 和 LinkedBlockingDeque。这些队列特别设计用于多线程环境，可以提高并发程序的性能和安全性。下面将详细介绍这些阻塞队列的特点及其使用方式。

LinkedBlockingQueue

LinkedBlockingQueue 是一个由链表结构组成的阻塞队列。它是一个可选容量限制的阻塞队列，它使用链表作为基础结构，并且具有良好的吞吐量。

特点：

• 可以指定容量上限，也可以使用默认的无界容量（Integer.MAX_VALUE）。
• 使用链表作为基础结构，因此插入和移除操作的时间复杂度为 O(1)。
• 默认情况下是非公平的，但可以通过构造函数指定公平性。
• 适用于需要高吞吐量的场景，特别是当队列的容量不是严格限制的时候。

示例代码：

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class LinkedBlockingQueueExample {
    public static void main(String[] args) throws InterruptedException {
        BlockingQueue<String> queue = new LinkedBlockingQueue<>(10);

        // 生产者线程
        Thread producer = new Thread(() -> {
            try {
                for (int i = 0; i < 15; i++) {
                    queue.put("item-" + i);
                    System.out.println("Produced: item-" + i);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        // 消费者线程
        Thread consumer = new Thread(() -> {
            try {
                for (int i = 0; i < 15; i++) {
                    String item = queue.take();
                    System.out.println("Consumed: " + item);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

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

        producer.join();
        consumer.join();
    }
}

LinkedBlockingDeque

LinkedBlockingDeque 是一个双端阻塞队列。它支持在两端进行插入、移除和检查操作，并且可以指定容量上限。

特点：

• 可以指定容量上限，也可以使用默认的无界容量（Integer.MAX_VALUE）。
• 使用双向链表作为基础结构，因此在两端进行插入和移除操作的时间复杂度为 O(1)。
• 适用于需要在两端进行操作的场景，比如实现滑动窗口算法等。
• 提供了 offerFirst, offerLast, pollFirst, pollLast, peekFirst, peekLast 等方法。

示例代码：

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

public class LinkedBlockingDequeExample {
    public static void main(String[] args) throws InterruptedException {
        BlockingDeque<String> deque = new LinkedBlockingDeque<>(10);

        // 生产者线程
        Thread producer = new Thread(() -> {
            try {
                for (int i = 0; i < 15; i++) {
                    deque.putFirst("item-" + i);
                    System.out.println("Produced: item-" + i);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        // 消费者线程
        Thread consumer = new Thread(() -> {
            try {
                for (int i = 0; i < 15; i++) {
                    String item = deque.takeLast();
                    System.out.println("Consumed: " + item);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

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

        producer.join();
        consumer.join();
    }
}

总结

LinkedBlockingQueue 和 LinkedBlockingDeque 都是高性能的阻塞队列实现，它们使用链表作为基础数据结构，因此插入和移除操作的时间复杂度较低。LinkedBlockingQueue 适用于需要单端操作的场景，而 LinkedBlockingDeque 则适用于需要在两端进行操作的场景。

在使用这些队列时，通常会结合生产者-消费者模型来实现线程间的同步和通信。这些队列可以有效地帮助管理线程间的同步问题，提高并发性能。