You may wrap all accesses with a RW lock. see:

java.sun.com/.../ReadWriteLock\
.html

java.sun.com/.../ReentrantRead\
WriteLock.html

As I know, there is no pre-built structure  satisfying your requirements (at least in JDK). you have to wrap your map  by your own-built class and for locking use java.sun.com/.../ReentrantReadWriteLock.html. With this class you can completely control your read- and write-locking. The class' javadoc has some samples. I found them useful.

I'm not really sure, but I think you should use Synchronized block or method for managing this case instead of just using a synchronized collection, you can synchronized the write methods but let the read  methods be non-synchronized, this may result in what you wanted.

I am sure your solution   will work, But I want to mention that using synchronized block is deprecated and has no more use. For additional information, read  java.util.concurrency package in JDK Javadocs.

Thanks a lot for your useful mention,it was really the case I needed to know.

I think You should Use ConcurrentHashMap , In your case I think ConcurrentHashMap is a good solution  ...

A hash table supporting full concurrency of retrievals and adjustable expected concurrency for updates. This class obeys the same functional specification as Hashtable, and includes versions of methods corresponding to each method of Hashtable. However, even though all operations are thread-safe, retrieval operations do not entail locking, and there is not any support for locking the entire table in a way that prevents all access. This class is fully interoperable with Hashtable in programs that rely on its thread  safety but not on its synchronization  details.

Retrieval operations (including get) generally do not block, so may overlap with update operations (including put and remove). Retrievals reflect the results of the most recently completed update operations holding upon their onset. For aggregate operations such as putAll and clear, concurrent retrievals may reflect insertion or removal of only some entries. Similarly, 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.


java.sun.com/.../ConcurrentHashMap.html

If you are using JDK 1.5 or higher this might help:
java.sun.com/.../ConcurrentHashMap.html

In Java 5 or later, you can use ConcurrentHashMap for this purpose. You can also use an implementation from Javolution package which is called FastMap. Both of them implement ConcurrentMap interface that includes some additional atomic methods such as putIfAbsent and replace.