LinkedList之间的区别 <T> 清晰和新的LinkedList <T> 在多线程环境中

Question

Why would this code:

public synchronized void update() {
        for(T event : eventQueue)
        {
            processEvent(event);
        }
        events = eventQueue;
        eventQueue = new LinkedList<T>();
}

run differently to this code:

public synchronized void update() {
            for(T event : eventQueue)
            {
                processEvent(event);
            }
            events = eventQueue;
            eventQueue.clear();
}

The first version works perfectly fine, however the second does not. The eventQueue.clear(); causes the app not to receive any events and finely crashes with a Concurrent Exception .

My app has two threads. The UI thread and the GameLoop thread. The UI thread adds events to the eventQueue like so:

public synchronized void addEvent(T newEvent) {
            eventQueue.add(newEvent);
}

The GameLoop thread calls the update method to get a copy (called events ) of the eventQueue .

All the code can be viewed from this website: http://entropyinteractive.com/2011/02/game-engine-design-input/

This seems kinda mysterious to me, since I thought eventQueue = new LinkedList<T>(); and eventQueue.clear(); would both result in an empty LinkedList ? I believe it has something todo with establishing a new reference (But why?!).

Answer 1

Because in this code:

public LinkedList<T> getEvents()
{
    return events;
}

You're returning the original list, not a copy. If you then clear() that list, you'll cause issues because you're removing things from the list (and more important, changing the size of the list) while the other thread is using it.

Note that this function isn't synchronized , so you can't even safely return a copy from it, because the original list could change while you're copying it (changing a reference is atomic , so it's safe to do that in your update() method).

You could return a copy from a synchronized method, like this:

public synchronized LinkedList<T> getEvents()
{
    return new LinkedList<T>(events);
}

But that introduces an unnecessary copy and lock. Whether that matters depends on if you care more about defensive coding or performance requirements. I assume they're doing it this way for performance reasons.

Answer 2

Here is your problem

  events = eventQueue;
  eventQueue.clear()

Once you assign events = eventQueue you are escaping the reference of eventQueue to the public via

public LinkedList<T> getEvents()
{
    return events;
}

One thread can be iterating over the getEvents() queue which actually is eventQueue and another thread can be invoking addEvent and since the synchronized in addEvent no longer matches with the iterator of getEvents() you will get the comodification.

My suggestion is if you really want to publish your events do it with a new collection.

  events = new LinkedList<T>(eventQueue);
  eventQueue.clear()

Answer 3

如果你不保护eventQueue 所有用法，比如在getEvents()分发引用，你应该尝试ConcurrentLinkedList 。