带有 RenderThread 和 UpdateThread 的游戏的 Java LinkedList 迭代器和线程安全

Question

我在一个有 2 个线程、一个渲染线程和一个更新线程的 Android 应用程序中有一个共享的 java LinkedList。两个线程都在持续运行并不断迭代共享的 LinkedList。有时更新线程必须从 LinkedList 中删除一个对象。我如何对程序进行编码以保持多线程性能但允许这种情况发生。我不断从渲染线程收到 java.util.ConcurrentModificationException，因为我猜想在我尝试渲染它时该对象被删除了。

请注意，我在我的代码中使用了迭代器...

public void run()
{
  if(Thread.currentThread() == renderThread)
  {
    while(true)
    {
      for(Iterator<GameObject> it = objects.iterator(); it.hasNext();)
      {
         it.next().render();
      }
    }
  }
  if(Thread.currentThread() == updateThread)
  {
    while(true)
    {
      for(Iterator<GameObject> it = objects.iterator(); it.hasNext();)
      {
         GameObject o = it.next();

         it.next().update();

         if(o.shouldBeRemoved())
             it.remove();
      }
    }
  }
}

一种可能的解决方案是捕获异常并忽略它，但我觉得这是骗子的出路，因为异常应该用于异常情况，而不是流。

Answer 1

你是modifying your list structurally在更新线程中，同时，渲染线程创建了一个迭代器并且玩得很开心迭代你的对象。您会收到ConcurrentModificationException 作为未处理同步问题的惩罚。

尝试使用 同步块/方法 和 wait()/notify() 搜索任何示例。

UPD：好的，这是对您的代码的简单修改，它不会引发异常。这不是 List 同步的一个很好的例子，你没有获得太多的性能（更新和渲染操作仍然在不同的线程中，但是按顺序执行），并且需要考虑的事情很少 - 如果任何其他线程试图修改你的 List，你仍然会得到一个并发异常。

在你的启动器类中定义两个线程：

private Thread t1, t2;

启动线程的代码（例如，inside public static void main(..)）：

final List<GameObject> list = initList();//some initialization
t1 = new Thread(new Runnable() {
        @Override
        public void run() {
            myMultipurposeMethod(list);
        }
    });

 t2 = new Thread(new Runnable() {
        @Override
        public void run() {
            myMultipurposeMethod(list);
        }
    });
 t1.start();
 t2.start();

现在是 GameObject 类的简化版本。注意同步块：

class GameObject {

    private int id;
    private static int count = 0;
    private boolean shouldDelete = false;
    private Object monitor = new Object();//will be used to lock critical section

    public GameObject() {
        id = ++count;
    }


    public void update(Thread thread) {
        synchronized (monitor) {
            shouldDelete = Math.random() < 0.5;//just a simple randomization
            System.out.println(thread.getName() + " updates GameObject. should be removed =" + shouldBeRemoved());
        }
    }

    public boolean shouldBeRemoved() {
        synchronized (monitor) {
            return shouldDelete;
        }
    }

    public void render(Thread thread) {
        System.out.println(thread.getName() + " renders GameObject " + id);
    }
}

最后，你的多用途方法：

public void myMultipurposeMethod(List<GameObject> ls) {
    synchronized (ls) {
        if (Thread.currentThread().equals(t1)) {
            while (true) {                    
                for (Iterator<GameObject> i = ls.iterator(); i.hasNext(); ) {
                    i.next().render(Thread.currentThread());
                    ls.notify();
                }
                try {
                    ls.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        } else if (Thread.currentThread().equals(t2)) {
            while (true) {
                for (Iterator<GameObject> i = ls.iterator(); i.hasNext(); ) {
                    GameObject o = i.next();
                    o.update(Thread.currentThread());
                    if (o.shouldBeRemoved()) {
                        i.remove();
                        System.out.println("game object with id=" + o.id + " marked as garbage and was removed");
                    }
                }
                ls.notify();

                try {
                    ls.wait();
                } catch (InterruptedException e) {
                    e.printStackTract();
                }
            }
        }
    }
}

如果您遵循序言中给出的要求，这会给您一种并行执行的错觉并防止您的异常发生。但是，为了获得真正的性能提升，您最好遵循 cmets 中提供给 OP 的 @isnot2bad 建议。