Java 入门指南：Java 并发编程 —— 并发容器 LinkedBlockingQueue

BlockingQueue

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

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

常用的实现类有：

• ArrayBlockingQueue
• LinkedBlockingQueue
• PriorityBlockingQueue
• SynchronousQueue
• LinkedBlockingDeque：LinkedBlockingDeque 详解
  等类，它们的实现方式各有不同。

适用场景

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) 带有超时时间的方法。

LinkedBlockingQueue

LinkedBlockingQueue 是 Java 中的一个线程安全的阻塞队列实现。实现了 BlockingQueue 接口，并使用链表作为底层数据结构，可以用于在生产者和消费者之间进行线程安全的数据传输。

特点

1. 队列容量：LinkedBlockingQueue 可以选择指定容量，也可以不指定容量（默认为 Integer.MAX_VALUE），即可以是有界队列或无界队列。

2. 先进先出（FIFO）：队列遵循先进先出的原则，即先入队的元素会先出队。

3. 阻塞操作：当队列为空时，消费者线程调用 take() 方法将被阻塞，直到有元素可用；当队列满时，生产者线程调用 put() 方法将被阻塞，直到队列有空间。

4. 链表实现：LinkedBlockingQueue 使用链表作为内部实现，这个链表由一系列的节点组成，每个节点都包含了一个元素以及指向下一个节点的引用。队列的头部和尾部都维护了对这些节点的引用，以便进行高效的入队和出队操作。

5. 线程安全：LinkedBlockingQueue内部通过锁机制确保了线程安全，所有公共方法都是原子的。

使用场景

1. 生产者-消费者模式：LinkedBlockingQueue 可以作为生产者和消费者之间的缓冲区，生产者将产品放入队列，消费者从队列中获取产品进行处理。

2. 线程池：线程池中的任务队列一般使用 LinkedBlockingQueue 实现，线程池根据需要动态地创建和销毁线程，将任务放入队列中，让线程从队列中获取任务进行处理。

3. 任务调度：LinkedBlockingQueue 可以作为任务调度的工具，将需要执行的任务放入队列中，再由任务调度器从队列中获取任务并执行。

构造方法

1. 创建初始容量为 Integer.MAX_VALUE 的无界队列。

LinkedBlockingQueue()

2. 创建指定容量的有界队列。如果队列已满，入队操作将会阻塞，直到队列中有空间。

LinkedBlockingQueue(int capacity)

3. LinkedBlockingQueue(Collection<? extends E> c): 创建队列，并将集合中元素按照顺序加入队列中，将队列大小初始化为元素的个数。

LinkedBlockingQueue(Collection<? extends E> collection)

LinkedBlockingQueue 使用示例

LinkedBlockingQueue 是 Java 并发包 java.util.concurrent 中的一个线程安全的阻塞队列实现，它基于链表结构存储数据，并且提供了阻塞操作，非常适合用于多线程环境下的数据交换和同步控制。

下面是一个使用 LinkedBlockingQueue 的简单示例，展示如何实现一个基本的生产者-消费者模型：

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;

public class LinkedBlockingQueueExample {

    public static void main(String[] args) {
        // 创建一个最大容量为 10 的 LinkedBlockingQueue
        LinkedBlockingQueue<String> queue = new LinkedBlockingQueue<>(10);

        // 创建生产者线程
        Thread producerThread = new Thread(() -> {
            try {
                for (int i = 0; i < 20; i++) {
                    String item = "Item " + i;
                    System.out.println("Producing: " + item);
                    // put 方法会在队列满的时候阻塞当前线程，直到有空间可用
                    queue.put(item);
                    TimeUnit.MILLISECONDS.sleep(200); // 模拟生产数据的时间间隔
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                System.out.println("Producer was interrupted");
            }
        });

        // 创建消费者线程
        Thread consumerThread = new Thread(() -> {
            try {
                for (int i = 0; i < 20; i++) {
                    String item = queue.take(); // take 方法会在队列空的时候阻塞当前线程，直到有数据可用
                    System.out.println("Consuming: " + item);
                    TimeUnit.MILLISECONDS.sleep(500); // 模拟消费数据的时间间隔
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                System.out.println("Consumer was interrupted");
            }
        });

        // 启动线程
        producerThread.start();
        consumerThread.start();

        // 等待线程结束
        try {
            producerThread.join();
            consumerThread.join();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

在这个例子中，我们创建了一个最大容量为 10 的 LinkedBlockingQueue。生产者线程会不断地尝试向队列中放入数据，而消费者线程则不断地尝试从中取出数据。当队列已满时，put 方法会让生产者线程等待，直到有空间可用；当队列为空时，take 方法会让消费者线程等待，直到有数据可用。这种机制保证了生产者和消费者之间的同步。