Java并发编程之ConcurrentLinkedQueue队列详情

什么是ConcurrentLinkedQueue

ConcurrentLinkedQueue是Java中的一个并发数据结构，基于链表实现，用来维护一组元素，采用无锁算法CAS保证线程安全，被广泛应用于多线程编程场景中。

操作模式

ConcurrentLinkedQueue操作模式是先进先出，和ArrayList、LinkedList的操作模式是一致的。

常用方法

• add(e): 将元素e添加到队列尾部
• offer(e): 将元素e添加到队列尾部，执行成功返回true，如果队列体积已满，则返回false
• poll(): 移除并返回队列头部元素，如果队列为空，则返回null
• peek(): 返回队列头部元素，如果队列为空，则返回null

示例1

再看一个示例：向ConcurrentLinkedQueue队列中添加和取出元素

import java.util.concurrent.ConcurrentLinkedQueue;

public class ConcurrentLinkedQueueExample {
    public static void main(String[] args) {
        ConcurrentLinkedQueue<Integer> queue = new ConcurrentLinkedQueue<>();

        // 添加元素
        queue.add(1);
        queue.offer(2);

        // 获取元素并打印
        System.out.println(queue.poll());
        System.out.println(queue.peek());
    }
}

输出：

1
2

示例2

再看一个示例：ConcurrentLinkedQueue多线程操作

import java.util.concurrent.ConcurrentLinkedQueue;

public class ConcurrentLinkedQueueExample2 {
    public static void main(String[] args) {
        ConcurrentLinkedQueue<Integer> queue = new ConcurrentLinkedQueue<>();
        Thread producerThread = new Thread(new Producer(queue));
        Thread consumerThread = new Thread(new Consumer(queue));
        producerThread.start();
        consumerThread.start();
    }
}

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

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

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            queue.add(i);
            System.out.println("Produce " + i);
            try {
                Thread.sleep((int)(Math.random() * 1000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

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

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

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            Integer value = queue.poll();
            if (value == null) {
                System.out.println("Consumer wait");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                value = queue.poll();
            }
            System.out.println("Consume " + value);
            try {
                Thread.sleep((int)(Math.random() * 2000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

输出：

Produce 0
Consumer wait
Produce 1
Consumer wait
Produce 2
Consume 0
Consume 1
Consume 2
Produce 3
Produce 4
Consumer wait
Produce 5
Consume 3
Produce 6
Consume 4
Produce 7
Consume 5
Produce 8
Consume 6
Produce 9
Consume 7
Consume 8
Consume 9

这个例子展示了ConcurrentLinkedQueue的高并发特性，当生产速度快于消费速度时，消费线程会等待，直到生产完成。当消费速度快于生产速度时，生产线程会等待，直到消费完成。这个例子充分体现了ConcurrentLinkedQueue的无阻塞特性，由于没有锁的完全互斥，因此多线程并发操作时效率更高。

总结

本文介绍了Java中ConcurrentLinkedQueue队列的基本概念、优点，以及常用方法示例。对于多线程下队列的一些处理，是使用ConcurrentLinkedQueue的理想场景。不仅可以避免因加锁对性能的影响，而且可以最大程度的避免出现死锁的现象。