Java并发编程 - JUC阻塞队列（概念、生产者消费者模型）

用心去追梦

于 2024-08-19 10:42:03 发布

阅读量586

点赞数 21

文章标签： java 开发语言

本文链接：https://blog.csdn.net/qq_33240556/article/details/141318715

版权

Java 并发编程中的 java.util.concurrent（简称 JUC）包提供了多种阻塞队列类，这些队列特别设计用于多线程环境，可以提高并发程序的性能和安全性。下面将详细介绍阻塞队列的概念、生产者消费者模型以及 JUC 中提供的几种阻塞队列实现。

阻塞队列（Blocking Queue）

阻塞队列是一种特殊的队列，它具有以下特性：

当队列为空时，从队列中取元素的操作将会被阻塞，直到队列中有元素可供取出。
当队列满时，往队列里插入元素的操作将会被阻塞，直到队列中有空闲空间可用。

阻塞队列在多线程编程中非常有用，特别是在生产者-消费者模型中，它可以作为生产者和消费者之间的缓冲区，实现线程间的同步和通信。

生产者消费者模型

生产者消费者模型是一种经典的多线程编程模式，其中生产者线程负责生成数据并将其放入队列中，而消费者线程负责从队列中取出数据并进行处理。

主要组件

生产者：负责生成数据并将数据放入队列中。
消费者：负责从队列中取出数据并进行处理。
队列：作为生产者和消费者之间的缓冲区。

示例

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

public class ProducerConsumerExample {
    private static final BlockingQueue<Integer> queue = new LinkedBlockingQueue<>(10);

    public static void main(String[] args) throws InterruptedException {
        Thread producer = new Thread(() -> {
            try {
                produce();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        Thread consumer = new Thread(() -> {
            try {
                consume();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

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

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

    private static void produce() throws InterruptedException {
        int i = 0;
        while (i < 10) {
            queue.put(i++);
            System.out.println("Produced: " + (i - 1));
        }
    }

    private static void consume() throws InterruptedException {
        while (true) {
            int item = queue.take();
            System.out.println("Consumed: " + item);
        }
    }
}

在这个示例中，我们使用 LinkedBlockingQueue 作为阻塞队列。生产者线程通过 put 方法向队列中添加数据，而消费者线程通过 take 方法从队列中取出数据。

JUC 阻塞队列实现

java.util.concurrent 包提供了多种阻塞队列实现，每种实现都有其特点：

ArrayBlockingQueue
- 特点：基于数组的阻塞队列，固定大小。
- 构造方法：可以指定容量和是否公平。
LinkedBlockingQueue
- 特点：基于链表的阻塞队列，可以指定容量或不限制容量。
- 构造方法：可以指定容量，默认为 Integer.MAX_VALUE。
PriorityBlockingQueue
- 特点：基于优先级的阻塞队列，元素按照优先级排序。
- 构造方法：可以指定容量，默认为 Integer.MAX_VALUE。
SynchronousQueue
- 特点：不存储元素的阻塞队列，每个 put 必须等待一个 take。
- 构造方法：可以指定是否使用公平策略。
DelayQueue
- 特点：存储延迟元素的阻塞队列，元素在达到指定的延迟时间后才能被消费。
- 构造方法：无参构造方法。

示例

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

public class ArrayBlockingQueueExample {
    public static void main(String[] args) throws InterruptedException {
        BlockingQueue<String> queue = new ArrayBlockingQueue<>(3);

        // 生产者线程
        Thread producer = new Thread(() -> {
            try {
                for (int i = 0; i < 5; 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 < 5; i++) {
                    String item = queue.take();
                    System.out.println("Consumed: " + item);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

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

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