java-04 数据结构-队列-ConcurrentLinkedQueue队列详解及应用

wyh106115

已于 2024-10-09 09:55:09 修改

阅读量773

点赞数 5

分类专栏： java基础文章标签： java 算法数据结构

于 2024-10-09 09:32:37 首次发布

本文链接：https://blog.csdn.net/wyh106115/article/details/142775832

版权

java基础专栏收录该内容

11 篇文章 0 订阅

订阅专栏

ConcurrentLinkedQueue是非阻塞线程安全的队列，适用于“高并发”的场景。是一个基于链接节点的无界线程安全队列，按照 FIFO（先进先出）原则对元素进行排序。队列元素中不可以放置null元素（内部实现的特殊节点除外）

如果你觉得我分享的内容或者我的努力对你有帮助，或者你只是想表达对我的支持和鼓励，请考虑给我点赞、评论、收藏。您的鼓励是我前进的动力，让我感到非常感激。

1 特点

ConcurrentLinkedQueue是基于链接节点的无界线程安全队列。此队列按照FIFO（先进先出）原则对元素进行排序。队列的头部是队列中存在时间最长的元素，而队列的尾部则是最近添加的元素。新的元素总是被插入到队列的尾部，而队列的获取操作（例如poll或peek）则是从队列头部开始。

与传统的LinkedList不同，ConcurrentLinkedQueue使用了一种高效的非阻塞算法，被称为无锁编程（Lock-Free programming），它通过原子变量和CAS(Compare-And-Swap)操作来保证线程安全，而不是通过传统的锁机制。这使得它在高并发场景下具有出色的性能表现。

2 使用场景

当多个线程共享访问一个公共集合时，ConcurrentLinkedQueue是一个非常好的选择。特别是在以下场景中，ConcurrentLinkedQueue的优势尤为明显：

2.1. 高并发场景

由于ConcurrentLinkedQueue采用了无锁编程技术，它在高并发环境下的性能表现非常出色。当大量线程同时读写队列时，它能够保持较高的吞吐量。

2.2. 需要快速插入和删除的场景

由于队列的头部和尾部都可以进行快速的插入和删除操作，这使得ConcurrentLinkedQueue在处理需要频繁插入和删除元素的场景时非常高效。

2.3. 无界队列场景

与ArrayBlockingQueue等有界队列不同，ConcurrentLinkedQueue是一个无界队列，这意味着它可以存储任意数量的元素。当然，在实际应用中，我们仍然需要考虑内存限制和垃圾回收等因素。

3 主要方法

ConcurrentLinkedQueue提供了丰富的方法来操作队列，包括：

offer(E e)：将指定的元素插入此队列的尾部。
add(E e)：将指定的元素插入此队列的尾部（与offer方法功能相同，但在失败时抛出异常）。
poll()：获取并移除此队列的头部，如果此队列为空，则返回null。
peek()：获取但不移除此队列的头部，如果此队列为空，则返回null。
size()：返回此队列中的元素数量。需要注意的是，由于并发的原因，这个方法返回的结果可能并不准确。如果需要在并发环境下获取准确的元素数量，建议使用java.util.concurrent.atomic包中的原子变量进行计数。
isEmpty()：检查此队列是否为空。与size()方法类似，由于并发的原因，这个方法返回的结果也可能不准确。

需要注意的是，在并发环境下使用size()和isEmpty()方法时需要特别小心，因为它们的结果可能并不准确。如果需要精确的元素数量或空队列检测，建议使用额外的同步机制或原子变量来实现。

4 生产和消费案例

import java.util.concurrent.ConcurrentLinkedQueue;

public class ProducerConsumerExample {

    // 定义一个并发队列，用于存储生产者生产的数据
    private static final ConcurrentLinkedQueue<Integer> queue = new ConcurrentLinkedQueue<>();

    // 生产者任务，负责生产数据并放入队列
    private static class Producer implements Runnable {
        private final int maxItemsToProduce; // 生产者最大生产数量

        public Producer(int maxItemsToProduce) {
            this.maxItemsToProduce = maxItemsToProduce;
        }

        @Override
        public void run() {
            for (int i = 0; i < maxItemsToProduce; i++) {
                queue.offer(i); // 将生产的数据放入队列
                System.out.println("生产者生产了数据：" + i);
                try {
                    // 模拟生产需要的时间
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    Thread.currentThread().interrupt();
                }
            }
            System.out.println("生产者完成生产任务");
        }
    }

    // 消费者任务，负责从队列中取出数据并处理
    private static class Consumer implements Runnable {
        @Override
        public void run() {
            while (true) {
                Integer item = queue.poll(); // 从队列中取出数据
                if (item != null) {
                    System.out.println("消费者消费了数据："+Thread.currentThread().getName() +" "+ item);
                    // 模拟消费需要的时间
                    try {
                        Thread.sleep(200);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                        Thread.currentThread().interrupt();
                    }
                } else {
                    // 如果队列为空，消费者稍微等待后继续尝试
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                        Thread.currentThread().interrupt();
                    }
                }
                // 在实际应用中，可以通过某种条件来终止消费者的循环，例如接收到停止信号
            }
        }
    }

    public static void main(String[] args) {
        // 启动生产者线程
        new Thread(new Producer(10)).start();

        // 启动两个消费者线程
        new Thread(new Consumer()).start();
        new Thread(new Consumer()).start();
    }
}

我们定义了一个Producer类和一个Consumer类，分别实现了Runnable接口。Producer在run方法中生产数据（0到maxItemsToProduce-1的整数），并放入ConcurrentLinkedQueue。Consumer在run方法中不断尝试从队列中取出数据并处理。

在主方法中，我们启动了一个生产者线程和两个消费者线程。生产者线程会生产10个数据放入队列，然后结束。消费者线程则会持续从队列中取出数据并处理，直到程序被外部中断或者你通过某种方式通知它们停止。

5 总结

ConcurrentLinkedQueue是Java并发编程中的一个重要工具，它提供了线程安全的无界非阻塞队列实现。通过高效的无锁编程技术，它能够在高并发场景下保持出色的性能表现。在需要快速插入和删除元素、无界队列以及高并发访问等场景中，ConcurrentLinkedQueue都是一个非常好的选择。然而，在使用时我们也需要注意其size()和isEmpty()方法可能带来的并发问题，并根据具体需求选择合适的同步机制或原子变量进行辅助处理。