Is it a good way to prevent ConcurrentModificationException

The another question is about synchronized. I have also a run() in class Note,because i want to output each element in notes every 5 minutes. But i get always exception:java.util.ConcurrentModificationException,if i try to make more meetings in main. so i applay synchronized to the list notes which may be added a new meeting when i iterate over notes.My开发者_Python百科 run method like this:

Is it correct way hier on list notes to synchronized to prevent ConcurrentModificationException ?(In my program it works.I get never this exception now)

A Meeting class and Note class may likes this:

public class Meeting{

    public Meeting(Note note_1,Note note_2){

                 note_1.addElement(this);

                 note_2.addElement(this);}

                 //another method hier 

                  }

public class Note implements Runnable{

    public final List<Meeting> notes = new ArrayList<Meeting>();

    public void addElement(Meeting n){

               entries.add(n);
              }

   @Override

   public void run(){
             while(true) {
             for(Meeting n : notes){

                 System.out.println(n.toString);}

                 }

             try{ Thread.sleep(10);}

             }

           }
          }

I get always exception error about exception:java.util.ConcurrentModificationException if i try to make more Meeting in main ,So i changes a littel in class Note,likes this :

  private  static final List<Entry> entries = Collections.synchronizedList(new ArrayList<Entry>());

and in run()

@Override
public void run() {
    while(true){
        synchronized(notes){
            for(Entry n : entries){
                 //do something
                 }
            }
            try {   
                Thread.sleep(10);  
         } catch (InterruptedException e ) {
            } 
     }
   }

}

From the javadoc

Note that this exception does not always indicate that an object has been concurrently modified by a different thread. If a single thread issues a sequence of method invocations that violates the contract of an object, the object may throw this exception. For example, if a thread modifies a collection directly while it is iterating over the collection with a fail-fast iterator, the iterator will thow this exception.

THis means do not change your collection in a loop and iterate over it at the same time even in the same thread.

Read to what @Navi had written.

In a nutshell - NEVER remove/add elements of a collection in for each loop.

I once had that kind of problem and I decided to use http://code.google.com/p/google-collections/ There are some map/filter functions there (if I recall that methods were in Collections2 library).

If you are not willing to make the things right, you can always use the old-school iterator technique.

I've used a CopyOnWriteArrayList before when I encountered this sort of problem.

This makes a complete copy of the underlying array for each write, so it's not very efficient, but I've found it very useful for specific circumstances (e.g. a class which manages specialised event notification to some other classes)

This array never changes during the lifetime of the iterator, so interference is impossible and the iterator is guaranteed not to throw ConcurrentModificationException