Serguey Asael Shinder: CopyOnWriteArrayList iterates a snapshot, so it misses later adds and its remove throws
CopyOnWriteArrayList is the usual answer when a list of listeners is read by many threads and changed rarely:
List<Listener> listeners = new CopyOnWriteArrayList<>();
for (Listener l : listeners) {
l.onEvent(event); // another thread may add or remove meanwhile
}
That loop will never throw ConcurrentModificationException, and the javadoc of java.util.concurrent.CopyOnWriteArrayList explains why. Every mutating call, add, set and the rest, makes "a fresh copy of the underlying array", and the iterator "uses a reference to the state of the array at the point that the iterator was created". That array does not change while the iterator lives, "so interference is impossible".
The same sentence that gives the guarantee states its cost: "The iterator will not reflect additions, removals, or changes to the list since the iterator was created." A listener registered while the loop is running is not called in that pass. A listener removed while the loop is running still is, which matters if removal was meant to stop it from touching a resource that is being closed. The iterator() entry repeats it: the returned iterator "provides a snapshot of the state of the list when the iterator was constructed".

The second surprise comes from code that was written for ArrayList and moved over for thread safety:
Iterator<Listener> it = listeners.iterator();
while (it.hasNext()) {
if (it.next().isClosed()) {
it.remove(); // UnsupportedOperationException
}
}
The class description says element-changing operations on its iterators, remove, set and add, "are not supported" and throw UnsupportedOperationException. listIterator() says the same. The pattern that is correct for ArrayList fails here at run time, on the first match. Call listeners.removeIf(Listener::isClosed) instead, which works on the list itself, or remove through listeners.remove(l) after the loop.
The javadoc is also direct about when the class makes sense. Copying the array on every change "is ordinarily too costly", and the class "may be more efficient than alternatives when traversal operations vastly outnumber mutations". A list that grows on every request, such as a buffer of pending items, pays for a full array copy on each add. In that case use a concurrent queue, or a plain list guarded by a lock, and keep CopyOnWriteArrayList for data that is read far more often than it is written, accepting that each reader works from the version it started with.