Java中的BlockingQueue

程序媛小刘

于 2024-02-20 09:00:00 发布

阅读量449

点赞数 10

文章标签： java 开发语言

本文链接：https://blog.csdn.net/m0_60521228/article/details/136125734

版权

什么是BlockingQueue

BlockingQueue是Java并发包中的一个重要组件，它是一个支持两个附加操作的队列，即在队列为空时，获取元素的线程将会阻塞，直到有元素添加进队列；当队列已满时，试图添加元素的线程也会阻塞，直到队列中有元素被消费。这种队列就是所谓的阻塞队列。

BlockingQueue是一个接口，它继承自Queue接口，因此其实现类也可以作为Queue的实现来使用，而Queue又继承自Collection接口。BlockingQueue被广泛使用在“生产者-消费者”问题中，其主要原因是BlockingQueue提供了可阻塞的插入和移除的方法。

BlockingQueue的实现类主要有以下几种：

ArrayBlockingQueue：一个由数组支持的有界队列。此队列按 FIFO（先进先出）原则对元素进行排序。
LinkedBlockingQueue：一个由链接节点支持的可选有界队列。此队列按 FIFO（先进先出）排序元素。
PriorityBlockingQueue：一个由优先级堆支持的无界优先队列。此队列不保证同优先级元素的顺序。
DelayQueue：一个由优先级堆支持的、基于时间的调度队列。

BlockingQueue的方法主要有四组不同的操作方式，用于插入、移除以及对队列中的元素进行检查。如果尝试进行不允许的操作（例如在不允许的情况下插入或移除元素），那么有两种处理方式：一种是抛出一个异常，另一种是返回一个特殊值（null或false，具体取决于操作）。

总的来说，BlockingQueue是Java并发编程中的一个重要工具，它提供了线程安全的队列操作，使得多线程之间的协作更加简单、高效。

BlockingQueue代码示例

下面是一个简单的Java代码示例，展示了如何使用BlockingQueue来实现一个基本的生产者-消费者模型。

首先，我们定义一个Producer类，它负责向BlockingQueue中添加数据：

import java.util.concurrent.BlockingQueue;

public class Producer implements Runnable {
    private final BlockingQueue<Integer> queue;

    public Producer(BlockingQueue<Integer> queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        try {
            for (int i = 0; i < 10; i++) {
                System.out.println("Produced: " + i);
                queue.put(i); // 如果队列满了，线程会阻塞
                Thread.sleep(1000); // 模拟生产耗时
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

然后，我们定义一个Consumer类，它负责从BlockingQueue中取出数据：

import java.util.concurrent.BlockingQueue;

public class Consumer implements Runnable {
    private final BlockingQueue<Integer> queue;

    public Consumer(BlockingQueue<Integer> queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        try {
            while (true) {
                Integer item = queue.take(); // 如果队列为空，线程会阻塞
                System.out.println("Consumed: " + item);
                Thread.sleep(1500); // 模拟消费耗时
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

最后，我们在主程序中创建BlockingQueue，并启动生产者和消费者线程：

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

public class BlockingQueueExample {
    public static void main(String[] args) {
        BlockingQueue<Integer> queue = new LinkedBlockingQueue<>(5); // 创建一个有界队列，容量为5

        Producer producer = new Producer(queue);
        Consumer consumer = new Consumer(queue);

        // 启动生产者线程
        new Thread(producer, "Producer").start();

        // 启动消费者线程
        new Thread(consumer, "Consumer").start();
    }
}