迭代事件处理程序集合时，如何安全地从*回调中删除处理程序？

Question

I'm a little puzzled over something. Java's documentation tells us that there is no defined behavior when removing items from a collection while iterating over that collection using an Iterator object and that the only safe way to do so is to use Iterator.remove().

How then, would you safely remove an event handler from an ArrayList if, in the course of iterating through the list one of the handlers has decided that it's time to remove itself as a listener?

// in public class Dispatcher

public void dispatchEvent(){
    Iterator<IEventHandler> iterator = mHandlers.iterator();
    IEventHandler handler = null;
    while(iterator.hasNext()){
        handler = iterator.next();
        handler.onCallbackEvent();
    }
}

public void insertHandler(IEventHandler h){
    mHandlers.add(h);
}

public void removeHandler(IEventHandler h){
    mHandlers.remove(h);
}

Meanwhile, the handler was instantiated like this...

final Dispatcher d = new Dispatcher();
d.insertHandler(new IEventHandler(){
    @Override
    public void onCallbackEvent(){
        Log.i(" callback happened ");
        d.removeHandler(this);
    }
});

See the potential problem? You're removing the handler from the ArrayList as a result of the onCallbackEvent() declared in that specific handler while you're still iterating using the Iterator .

Is this an intractable problem? What's the safe way to handle this situation?

Answer 1

This is a very common problem when implementing an event system. The only solution is to copy the list of handlers on change. You can do this yourself in the insertHandler/removeHandler methods or just use CopyOnWriteArrayList.

Answer 2

You could reimplement removeHandler to store the handlers scheduled for removal.

public void removeHandler(IEventHandler h){
    mHandlersToRemove.add(h);
}

and then remove them before you do any dispatching.

public void dispatchEvent(){
    mHandlers.removeAll(mHandlersToRemove);
    mHandlersToRemove.clear();
    ...

You could also remove at the end of dispatchEvent , but then you could only remove from within handlers. (Otherwise you might dispatch to handlers that were removed.)

---

If you're interested in a theoretical solution to this problem, you can look at how C++ implements iterators. In an stl vector, the iterator has an erase method that returns the next valid iterator.

It would look something like this:

for (itr = listA.begin(); itr != listA.end(); )
{
    if ( shouldRemove(*itr) ) {
        itr = listA.erase(itr);
    }
    else {
      ++itr;
    }
}

Of course, this example doesn't apply to your question since it's both in C++ and it would be awkward to propagate the new iterator up to the top-level loop (or add a return value to your call for a "remove" condition). But maybe there's a similar java implementation somewhere out there : )