CODEWITHSUNDEEP
javamultithreading
Bober02
Bober02

Reputation: 15341

Multiple threads iterating over the same map

I was recently writing a concurrent program in Java and came across the dollowing dilemma: suppose you have a global data structure, which is partof regular non-synchronized, non-concurrent lib such as HashMap. Is it OK to allow multiple threads to iterate through the collection (just reading, no modifications) perhaps at different, interleaved periods i.e. thread1 might be half way thrpugh iterating when thread2 gets his iterator on the same map?

Upvotes: 8

Views: 5049

Answers (4)

Howard Schutzman
Howard Schutzman

Reputation: 2135

The above answers are certainly good advice. In general, when writing Java with concurrent threads, so long as you do not modify a data structure, you need not worry about multiple threads concurrently reading that structure.

Should you have a similar problem in the future, except that the global data structure could be concurrently modified, I would suggest writing a Java class that all threads use to access and modify the structure. This class could impleement its own concurrency methodology, using either synchronized methods or locks. The Java tutorial has a very good explanation of Java's concurrency mechanisms. I have personally done this and it is fairly straight forward.

Upvotes: 2

pcalcao
pcalcao

Reputation: 15990

Problems only arise when you attempt concurrent modifications on a data structure.

For instance, if one thread is iterating over the content of a Map, and another thread deletes elements from that collection, you'll be heading for serious trouble.

If you do need some threads to modify that collection safely, Java provides for mechanisms to do so, namely, ConcurrentHashMap.

ConcurrentHashMap in Java?

There is also Hashtable, which has the same interface as HashMap, but is synchronized, although it's use is not advised currently (deprecated), since it's performance suffers when the number of elements becomes larger (compared to ConcurrentHashMap which doesn't need to lock the entire Collection).

If you happen to have a Collection that is not synchronized and you need to have several threads reading and writing on top of it, you can use Collections.synchronizedMap(Map) to get a synchronized version of it.

Upvotes: 4

amit
amit

Reputation: 178431

It should be fine, as long as there are no writers.

This issue is similar to the readers-writer lock, where multiple readers are allowed to read from the data, but not during the time a writer "has" the lock for it. There is no concurrency issue for multiples read at the same time. [data race can occure only when you have at least one write].

Upvotes: 7

AlexR
AlexR

Reputation: 115328

It is OK. Ability to do this is the reason to create such interface as iterator. Every thread iterating over collection has its own instance of iterator that holds its state (e.g. where you are now in your iterating process).

This allows several threads to iterate over the same collection simultaneously.

Upvotes: 12

Related Questions