BlockingQueue详解及其四组API

最新推荐文章于 2025-04-21 18:21:15 发布

isolusion

最新推荐文章于 2025-04-21 18:21:15 发布

阅读量1k

点赞数 25

文章标签： java

本文链接：https://blog.youkuaiyun.com/isolusion/article/details/146077632

版权

引言

一、BlockingQueue概述

1.1 什么是BlockingQueue？

1.2 BlockingQueue的实现类

二、BlockingQueue的四组API

引言

在多线程编程中，线程间的通信是一个非常重要的主题。BlockingQueue是Java并发包java.util.concurrent中提供的一个线程安全的队列实现，它主要用于在生产者和消费者模式中实现线程间的数据传递。BlockingQueue不仅提供了线程安全的队列操作，还支持阻塞操作，即当队列为空时，消费者线程会被阻塞，直到队列中有新的元素；当队列满时，生产者线程会被阻塞，直到队列中有空闲空间。

本文将详细介绍BlockingQueue的概念、使用场景以及其四组核心API。

一、BlockingQueue概述

1.1 什么是BlockingQueue？

BlockingQueue是一个支持阻塞操作的队列接口，它继承自Queue接口。BlockingQueue的主要特点是：

线程安全：所有操作都是线程安全的，多个线程可以安全地访问同一个BlockingQueue。
阻塞操作：当队列为空时，消费者线程会被阻塞，直到队列中有新的元素；当队列满时，生产者线程会被阻塞，直到队列中有空闲空间。
容量限制：BlockingQueue可以是有界队列（容量有限）或无界队列（容量无限）。

阻塞队列是一个队列，在数据结构中起的作用如下图：

当队列是空的，从队列中获取元素的操作将会被阻塞。

当队列是满的，从队列中添加元素的操作将会被阻塞。

试图从空的队列中获取元素的线程将会被阻塞，直到其他线程往空的队列插入新的元素。

试图向已满的队列中添加新元素的线程将会被阻塞，直到其他线程从队列中移除一个或多个元素或者完全清空，使队列变得空闲起来并后续新增。

1.2 BlockingQueue的实现类

BlockingQueue有多个实现类，常用的有：

ArrayBlockingQueue：基于数组实现的有界阻塞队列。
LinkedBlockingQueue：基于链表实现的可选有界或无界阻塞队列。
PriorityBlockingQueue：支持优先级排序的无界阻塞队列。
SynchronousQueue：不存储元素的阻塞队列，每个插入操作必须等待另一个线程的移除操作。
DelayQueue：基于优先级队列实现的无界阻塞队列，用于存放实现了Delayed接口的元素。

二、BlockingQueue的四组API

BlockingQueue提供了四组不同的API，用于在不同的场景下进行队列操作。这四组API分别是：

抛出异常的操作
返回特定值的操作
阻塞线程的操作
超时等待的操作

2.1 抛出异常的操作

这组操作在队列满或空时会抛出异常。

add(E e)：将元素插入队列，如果队列已满，抛出IllegalStateException异常。
remove()：移除并返回队列头部的元素，如果队列为空，抛出NoSuchElementException异常。
element()：返回队列头部的元素，但不移除它，如果队列为空，抛出NoSuchElementException异常。

BlockingQueue<String> queue = new ArrayBlockingQueue<>(10);
queue.add("element1"); // 正常插入
queue.add("element2"); // 正常插入
String head = queue.remove(); // 移除并返回头部元素
String peek = queue.element(); // 返回头部元素但不移除

2.2 返回特定值的操作

这组操作在队列满或空时会返回特定的值（false或null），而不是抛出异常。

offer(E e)：将元素插入队列，如果队列已满，返回false。
poll()：移除并返回队列头部的元素，如果队列为空，返回null。
peek()：返回队列头部的元素，但不移除它，如果队列为空，返回null。

BlockingQueue<String> queue = new ArrayBlockingQueue<>(10);
boolean isInserted = queue.offer("element1"); // 插入成功返回true
String head = queue.poll(); // 移除并返回头部元素，队列为空时返回null
String peek = queue.peek(); // 返回头部元素但不移除，队列为空时返回null

2.3 阻塞线程的操作

这组操作在队列满或空时会阻塞线程，直到条件满足。

put(E e)：将元素插入队列，如果队列已满，阻塞线程直到队列有空闲空间。
take()：移除并返回队列头部的元素，如果队列为空，阻塞线程直到队列中有新元素。

BlockingQueue<String> queue = new ArrayBlockingQueue<>(10);
queue.put("element1"); // 插入元素，队列满时阻塞
String head = queue.take(); // 移除并返回头部元素，队列为空时阻塞

2.4 超时等待的操作

这组操作在队列满或空时会阻塞线程一段时间，如果在指定时间内条件仍未满足，则返回特定值（false或null）。

offer(E e, long timeout, TimeUnit unit)：将元素插入队列，如果队列已满，阻塞线程直到队列有空闲空间或超时。
poll(long timeout, TimeUnit unit)：移除并返回队列头部的元素，如果队列为空，阻塞线程直到队列中有新元素或超时。

BlockingQueue<String> queue = new ArrayBlockingQueue<>(10);
boolean isInserted = queue.offer("element1", 1, TimeUnit.SECONDS); // 插入元素，队列满时阻塞1秒
String head = queue.poll(1, TimeUnit.SECONDS); // 移除并返回头部元素，队列为空时阻塞1秒

三、BlockingQueue的使用场景

BlockingQueue非常适合用于生产者-消费者模式。生产者线程将数据放入队列，消费者线程从队列中取出数据进行处理。由于BlockingQueue的阻塞特性，生产者和消费者线程可以高效地协同工作，而不需要额外的同步机制。

3.1 生产者-消费者示例

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ArrayBlockingQueue;

public class ProducerConsumerExample {
    public static void main(String[] args) {
        BlockingQueue<String> queue = new ArrayBlockingQueue<>(10);

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

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

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

在这个示例中，生产者线程将20个元素放入队列，消费者线程从队列中取出并处理这些元素。由于BlockingQueue的阻塞特性，生产者和消费者线程可以高效地协同工作。