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

BlockingQueue

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

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

常用的实现类有:

  • ArrayBlockingQueue:并发容器 ArrayBlockingQueue 详解
  • LinkedBlockingQueue
  • PriorityBlockingQueue:并发容器 PriorityBlockingQueue 详解
  • SynchronousQueue:并发容器 SynchronousQueue 详解
  • LinkedBlockingDeque:LinkedBlockingDeque 详解
    等类,它们的实现方式各有不同。

适用场景

BlockingQueue 通常用于一个线程生产对象,而另外一个线程消费这些对象的场景。

Java 入门指南:Java 并发编程 —— 并发容器 LinkedBlockingQueue_第1张图片

一个线程将会持续生产新对象并将其插入到队列之中,直到队列达到它所能容纳的临界点

如果该阻塞队列到达了其临界点,生产者线程将会在往里边插入新对象时发生阻塞。它会一直处于阻塞之中,直到消费者线程从队列中拿走一个对象。

消费者线程将会一直从该阻塞队列中拿出对象。如果消费线程尝试去从一个空的队列中提取对象的话,这个消费线程将会处于阻塞之中,直到一个生产线程把一个对象丢进队列。

常用方法

  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()
  1. 创建指定容量的有界队列。如果队列已满,入队操作将会阻塞,直到队列中有空间。
LinkedBlockingQueue(int capacity)
  1. LinkedBlockingQueue(Collection 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 方法会让消费者线程等待,直到有数据可用。这种机制保证了生产者和消费者之间的同步。

你可能感兴趣的:(Java,java,开发语言,intellij-idea,个人开发,团队开发,后端)