同时迭代修改Java队列遇并发异常，求适配读写分离需求的标准数据结构

Great question! Let's break down your needs and find the right tools from the standard library to solve this.

You're looking for a structure that acts two ways:

• As a Queue for writes: append to the tail, remove from the head
• As a List for reads: traverse with a stable pointer (iterator) that doesn't throw ConcurrentModificationException when the queue is modified from the outside.

The problem with regular Iterator is its fail-fast behavior—it detects external modifications to the collection and throws that exception. ListIterator fixes some of that by allowing in-place adds/removes, but it can't handle the queue-style head/tail operations you need for writes.

1. LinkedList + Manual Pointer Tracking #

LinkedList already implements the Queue interface, so it natively supports add() (append to tail) and poll() (remove from head). Instead of relying on an iterator, you can track your current position with an integer index:

• When you call poll() (remove head), if your current index is greater than 0, decrement it by 1 to account for the shifted elements.
• Use get(index) to access the current element, then increment the index to move to the next one.

Note: LinkedList's get() is O(n) time, so this works best if your traversal is sequential (which it sounds like it is) rather than random access.

2. ConcurrentLinkedQueue for Thread-Safe Scenarios #

If you need thread safety, ConcurrentLinkedQueue is a solid pick. Its iterator is weakly consistent—meaning it won't throw ConcurrentModificationException when the queue is modified. The iterator will show the state of the queue when the iterator was created, or any changes made after that (but might miss some recent updates if they're in flight).

This fits your read perspective: you can create an iterator once, then call next() to move through elements, even as the queue is being enqueued/dequeued from other threads. The tradeoff is you can't go backward in the iterator, but that sounds like it aligns with your "move to next element" requirement.

3. Custom Wrapper Class (Tailored to Your Exact Needs) #

If the above options don't fit perfectly, a simple wrapper around LinkedList lets you combine queue operations with a stable traversal pointer:

public class QueueList<T> {
    private final LinkedList<T> backingList = new LinkedList<>();
    private ListIterator<T> traversalIterator;

    // Queue operation: append to tail
    public void enqueue(T item) {
        backingList.add(item);
    }

    // Queue operation: remove from head
    public T dequeue() {
        T removedItem = backingList.poll();
        if (removedItem != null && traversalIterator != null && traversalIterator.hasPrevious()) {
            // Adjust iterator if we removed the element before our current position
            traversalIterator.previous();
            traversalIterator.next(); // Reset iterator state after adjustment
        }
        return removedItem;
    }

    // List traversal: move to next element
    public T getNext() {
        if (traversalIterator == null) {
            traversalIterator = backingList.listIterator();
        }
        return traversalIterator.hasNext() ? traversalIterator.next() : null;
    }
}

This wrapper handles both queue-style writes and stable list-style traversal without any concurrent modification exceptions.

There's no single standard data structure that perfectly checks all your boxes out of the box, but combining or wrapping existing standard library classes gives you exactly what you need:

• For non-thread-safe use cases: LinkedList with manual index tracking or a custom wrapper
• For thread-safe use cases: ConcurrentLinkedQueue with its weakly consistent iterator

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