Java 当列表被迭代时，它可能被添加到列表中。然而，据我所知，这只能是并发过程的结果。@jeremynealbrown那么同步必须在程序的某个地方被破坏。在某个时刻，您的集合正在被修改，而其他地方正在被迭代。考虑到大多数集合迭代器都是由原始集合支持的，并且每个循环

---

当列表被迭代时，它可能被添加到列表中。然而，据我所知，这只能是并发过程的结果。@jeremynealbrown那么同步必须在程序的某个地方被破坏。在某个时刻，您的集合正在被修改，而其他地方正在被迭代。考虑到大多数集合迭代器都是由原始集合支持的，并且每个循环都在幕后使用迭代器。将迭代过程包装在同步块中似乎很好地解决了这一问题。它不仅解决了问题，我还学到了一些非常有用的技巧，我相信我会再次使用这些技巧。谢谢你们的帮助。！！您是否查看过CopyOnWriteArrayList或ConcurrentHashMap？这两种方法都有助于避免ConcurrentModificationException for循环在列表上迭代，而您的osEvent会修改列表。同时运行的两个线程可能试图在列表上迭代，而另一个线程正在向列表中添加元素。for创建迭代器。是的，我看到问题了。但是我不确定如何避免这种情况。synchronized（list）{/*您在这里的循环*/}@jeremynealbrown假设只有这两种情况，您可以通过使方法

同步化

，或使用

synchronized（list）

在列表上同步访问。

Vector<String> list = new Vector<String>();
Vector<Particle> completedParticles = new Vector<Particle>();

public void oscEvent( OSCMessage message )
{
    list.add( new Particle( message.x, message.y ) );
}

public void draw()
{
    completedParticles.clear();
    for( Particle p : list )
    {
        p.draw();
        if( p.isComplete ) {
            completedParticles.add( p );
        }   
    }
    list.removeAll( completedParticles );
}

//osEvent
synchronized(this.list) {
   list.add( new Particle( message.x, message.y ) );
}

//draw
synchronized(this.list) {
  for( Particle p : list )
    {
        p.draw();
        if( p.isComplete ) {
            completedParticles.add( p );
        }   
    }
}

List<Book> books = new ArrayList<Book>();
books.add(new Book(new ISBN("0-201-63361-2")));
books.add(new Book(new ISBN("0-201-63361-3")));
books.add(new Book(new ISBN("0-201-63361-4")));

ISBN isbn = new ISBN("0-201-63361-2");
List<Book> found = new ArrayList<Book>();
for(Book book : books){
    if(book.getIsbn().equals(isbn)){
        found.add(book);
    }
}
books.removeAll(found);

ListIterator<Book> iter = books.listIterator();
while(iter.hasNext()){
    if(iter.next().getIsbn().equals(isbn)){
        iter.remove();
    }
}

synchronized(this.books) {
   List<Book> copyOfBooks = new ArrayList<Book>(this.books)
}
for(Book book : copyOfBooks) {
   System.out.println(book);
}

java.util.concurrent.locks.Lock lock = new java.util.concurrent.locks.ReentrantLock();
Vector<String> list = new Vector<String>();
Vector<Particle> completedParticles = new Vector<Particle>();

public void oscEvent( OSCMessage message )
{
    lock.lock();
    try {
      list.add( new Particle( message.x, message.y ) );
    } finally {
      lock.unlock();
    }
}

public void draw()
{
    completedParticles.clear();
    lock.lock();
    try {
      for( Particle p : list )
      {
          p.draw();
          if( p.isComplete ) {
              completedParticles.add( p );
          }   
      }
      list.removeAll( completedParticles );
    } finally {
      lock.unlock();
    }
}

// example only
public class LockingVector {
  private final Vector v;
  private final ReentrantLock lock = new ReentrantLock();

  public void lock(){
    lock.lock();
  }
  public void unlock(){
    lock.unlock();
  }

  // other 'vector' method delegated to v
  public Object get() {
    return v.get();
  }
}

 public class Main {
   public static void main(String[] args){
     Vector v = ...
     LockingVector lv = new LockingVector(v);
     try {
       lv.lock();
       // do stuff here (add, delete, iterate, etc.)
     } finally {
       lv.unlock();
     }
   }
 }