How to get a fixed state iterator for a set/map without cloning overheads

I'm looking to avoid a ConcurrentModificationException where the functionality is to iterate over an expanding set (ther开发者_如何学Goe are no removes), and the add operations are being done by different threads.

I considered cloning the collection before iterating, but if this solution doesn't scale very well as the set becomes large. Synchronizing doesn't work because the collection is being used in tonnes of places and the code is pretty old. Short of a massive refactoring, the only bet is to change the set implementation.

Wondering if there's a Java implementation where the iterator returns a snapshot state of the collection (which is okay for my functionality) but avoid the cost of cloning too much. I checked out CopyOnWriteArrayList but it doesn't fit the bill mainly because of being a list.

The java.util.concurrent package has everything you need.

The classes there are like the java.util collections, but are highly optimized to cater for concurrent access, interestingly addressing specifically your comment:

the iterator returns a snapshot state of the collection

Don't reinvent the wheel :)

Wondering if there's a Java implementation where the iterator returns a snapshot state of the collection

Yes, there is. Unlike the synchronized collections made available via the Collections.synchronizedxxx() methods, the Concurrentxxx classes in java.util.concurrent package would allow for this scenario. The concurrent collection classes allow for multiple threads to access the collection at the same point in time, without the need to synchronize on a lock.

Depending on the exact nature of your problem, ConcurrentHashMaps can be used. The relevant section of the documentation of the class, that applies to your problem is:

Iterators and Enumerations return elements reflecting the state of the hash table at some point at or since the creation of the iterator/enumeration. They do not throw ConcurrentModificationException. However, iterators are designed to be used by only one thread at a time.

Note the last sentence carefully.

Also, remember that these are not consistent snapshots of the collection being returned. The iterators from most methods returned possess the following property:

The view's iterator is a "weakly consistent" iterator that will never throw ConcurrentModificationException, and guarantees to traverse elements as they existed upon construction of the iterator, and may (but is not guaranteed to) reflect any modifications subsequent to construction.

Related questions

• Is iterating ConcurrentHashMap values thread safe?
• Java ConcurrentHashMap not thread safe.. wth?