ficient version Object key; ... Object value; ... synchronized(t) { if (!t.containsKey(key)) t.put(key, value); // other code if not previously present } else { // other code if it was previously present } } Instead, if the values are intended to be the same in each case, just take advantage of the fact that put returns null if the key was not previously present:
ConcurrentReaderHashMap t; ... // Use this instead Object key; ... Object value; ... Object oldValue = t.put(key, value); if (oldValue == null) { // other code if not previously present } else { // other code if it was previously present } Iterators and Enumerations (i.e., those returned by keySet().iterator(), entrySet().iterator(), values().iterator(), keys(), and elements()) return elements reflecting the state of the hash table at some point at or since the creation of the iterator/enumeration. They will return at most one instance of each element (via next()/nextElement()), but might or might not reflect puts and removes that have been processed since they were created. They do not throw ConcurrentModificationException. However, these iterators are designed to be used by only one thread at a time. Sharing an iterator across multiple threads may lead to unpredictable results if the table is being concurrently modified. Again, you can ensure interference-free iteration by enclosing the iteration in a synchronized block.
This class may be used as a direct replacement for any use of java.util.Hashtable that does not depend on readers being blocked during updates. Like Hashtable but unlike java.util.HashMap, this class does NOT allow null to be used as a key or value. This class is also typically faster than ConcurrentHashMap when there is usually only one thread updating the table, but possibly many retrieving values from it.
Implementation note: A slightly faster implementation of this class will be possible once planned Java Memory Model revisions are in place.
[ Introduction to this package. ]