can CopyOnWriteArrayList help to allowing remove item from different thread which has been put in a iterator

Question

having a map holds list of eventlisteners for same event by type as key,

func_1() will start to get the listenerlist of one type from the map and iterate the list to handle the event with every listener.

When one listener finishes its handling, it will ask to remove it from the listenerlist in the map.

since the listeners are in an iterator, and removing it from the original list will cause java.util.ConcurrentModificationException in the iterator.previous() for getting next listener.

question is if using CopyOnWriteArrayList to copy the listener list then iterator on it, since it is a copy of the list, will it still throw when the listener is removed from other thread?

does it make any difference just simply making a copy of normal list instead of CopyOnWriteArrayList to iterator on?

func_1(Event event) {

    List<WeakReference<EventListener<Event>>> listenerlist = mEventMap.get(event.eventType);

    /* instead of directly iterator on the listenerlist
    ListIterator<WeakReference<EventListener<Event>>> listenerIterator = 
         listenerlist.listIterator(listenerlist.size());
    but making a CopyOnWriteArrayList first:
    */
    List<WeakReference<EventListener<Event>>> listeners = 
                         new CopyOnWriteArrayList<>(listenerlist);

    ListIterator<WeakReference<EventListener<Event>>> listenerIterator = 
            listeners.listIterator(listeners.size());

    while(listenerIterator.hasPrevious()){
        WeakReference<EventListener<Event>> listenerItem =   
                                      listenerIterator.previous();
        //doing something
        listenerItem.func_2(event);
    }
}

EventListener::func_2(Event event){
   //do something
   //remove the type in the map

   funct_3(EventListener.this);

}

funct_3(EventListener listener) {
   List<WeakReference<EventListener<Event>>> listeners = 
             mEventMap.get(listener.eventType);

        if (listeners != null) {
            Iterator<WeakReference<EventListener<Event>>> listenerIterator = 
                                       listeners.iterator();
            while (listenerIterator.hasNext()) {
                WeakReference<EventListener<Event>> listenerItem = listenerIterator.next();
                if (listenerItem.get() != null && listenerItem.get() == listener) {
                    listenerIterator.remove();
                    break;
                }
            }
        }
}

Answer 1

Did the test and it does not throw because it is iterating on a copy of the list, while the removing happens on the original list.

The draw back is it might be costly if the event comes too often.

-https://www.ibm.com/developerworks/library/j-5things4/

"2. CopyOnWriteArrayList Making a fresh copy of an array is too expensive an operation, in terms of both time and memory overhead, to consider for ordinary use; developers often resort to using a synchronized ArrayList instead. That's also a costly option, however, because every time you iterate across the contents of the collection, you have to synchronize all operations, including read and write, to ensure consistency. This puts the cost structure backward for scenarios where numerous readers are reading the ArrayList but few are modifying it. CopyOnWriteArrayList is the amazing little jewel that solves this problem. Its Javadoc defines CopyOnWriteArrayList as a "thread-safe variant of ArrayList in which all mutative operations (add, set, and so on) are implemented by making a fresh copy of the array." The collection internally copies its contents over to a new array upon any modification, so readers accessing the contents of the array incur no synchronization costs (because they're never operating on mutable data). Essentially, CopyOnWriteArrayList is ideal for the exact scenario where ArrayList fails us: read-often, write-rarely collections such as the Listeners for a JavaBean event."