同步循环链表

Question

I am writing a program with 2 threads. one in iterating a circular linked list . the list has always a next element because the linked list is circular . another thread in modifying the list. but I get the concurrentModificationException. What can i do with it? Thanks

Answer 1

From the following api docs :

http://docs.oracle.com/javase/1.5.0/docs/api/java/util/ConcurrentModificationException.html

This exception may be thrown by methods that have detected concurrent modification of an object when such modification is not permissible.

For example, it is not generally permissible for one thread to modify a Collection while another thread is iterating over it. In general, the results of the iteration are undefined under these circumstances. Some Iterator implementations (including those of all the general purpose collection implementations provided by the JRE) may choose to throw this exception if this behavior is detected. Iterators that do this are known as fail-fast iterators, as they fail quickly and cleanly, rather that risking arbitrary, non-deterministic behavior at an undetermined time in the future.

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 throw this exception.

Answer 2

Don't use iterators in this case because that's where the exception comes from.

Advance the current element by simply setting currentElement = currentElement.next() or whatever it is called in your (infinite?) loop.

You might get into trouble when modifying the data structure concurrently should the list not be thread safe.

Answer 3

Assuming your implementation is threadsafe (which class are you using?) Iterators aren't inherently threadsafe. They don't hold a lock on the List, so they can't keep other threads from modifying it.

If your CircularList synchronizes on itself (not sure what you're using, but it's common for threadsafe lists - otherwise iterators would basically always been non-threadsafe), you can work around this by doing:

synchronized(list) {
  Iterator i = list.iterator();
  doSomething(i);
}

See also: http://docs.oracle.com/javase/1.5.0/docs/api/java/util/Collections.html#synchronizedList(java.util.List)