多线程环境下固定大小非阻塞并发队列的实现方案咨询

JDK标准库中没有直接提供满足你需求的现成队列实现——既线程安全、有界容量，又能在队列满时自动丢弃最旧元素而非阻塞。不过你可以基于现有线程安全队列封装实现，或者自定义实现，以下是具体方案：

方案一：基于ConcurrentLinkedQueue封装 #

利用ConcurrentLinkedQueue本身的线程安全特性，在外层添加容量控制的原子操作逻辑，保证添加元素时若超出容量则先移除队首（最旧）元素，再插入新元素。

import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.locks.ReentrantLock;

public class BoundedConcurrentQueue<E> {
    private final ConcurrentLinkedQueue<E> innerQueue;
    private final int maxCapacity;
    private final ReentrantLock lock = new ReentrantLock();

    public BoundedConcurrentQueue(int maxCapacity) {
        this.maxCapacity = maxCapacity;
        this.innerQueue = new ConcurrentLinkedQueue<>();
    }

    public boolean offer(E element) {
        lock.lock();
        try {
            if (innerQueue.size() >= maxCapacity) {
                // 移除最旧元素
                innerQueue.poll();
            }
            return innerQueue.offer(element);
        } finally {
            lock.unlock();
        }
    }

    // 按需实现其他队列方法
    public E poll() {
        return innerQueue.poll();
    }

    public int size() {
        return innerQueue.size();
    }
}

这里使用ReentrantLock确保"检查容量-移除旧元素-添加新元素"的操作原子性，避免多线程并发下出现队列容量超限的情况。

方案二：基于LinkedBlockingQueue改造 #

LinkedBlockingQueue本身是有界线程安全队列，但默认满时offer()会返回false而非阻塞。我们可以封装逻辑：当offer()失败时，先移除队首元素，再尝试添加新元素。

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.locks.ReentrantLock;

public class EvictingBoundedQueue<E> {
    private final LinkedBlockingQueue<E> innerQueue;
    private final int maxCapacity;
    private final ReentrantLock lock = new ReentrantLock();

    public EvictingBoundedQueue(int maxCapacity) {
        this.maxCapacity = maxCapacity;
        this.innerQueue = new LinkedBlockingQueue<>(maxCapacity);
    }

    public void add(E element) {
        lock.lock();
        try {
            // 若添加失败，先移除最旧元素再重试
            while (!innerQueue.offer(element)) {
                innerQueue.poll();
            }
        } finally {
            lock.unlock();
        }
    }

    // 按需实现其他队列方法
    public E poll() {
        return innerQueue.poll();
    }
}

加锁同样是为了保证并发场景下的操作原子性，避免出现队列状态不一致的问题。

自定义双向链表实现的考量 #

如果上述封装方案的性能无法满足你的业务需求，也可以自定义基于双向链表的线程安全队列。但需要自行处理所有并发控制逻辑（比如用AtomicReference管理节点、设计无锁算法或使用同步块），实现复杂度较高。除非有特殊性能要求，否则更推荐基于JDK现成队列的封装方案，可靠性和可维护性更强。

内容的提问来源于stack exchange，提问作者Citut