Java并发问题

Question

I know that we can have a Map designed so that, using a concurrent utility, it allows map data to be modify by single user at one time. I want to know if this concurrent behaviour is only applicable for put operations or also for specifically the size operation. The following code illustrates the question:

One thread is in this block of the code

if(map.size())
{
    //do something
}

while another thread is in this block

map.put(obj);

I want to know if the size operation gets halted until the put operation completes and vice versa.

Answer 1

In short, yes: size() must wait on a mutex before it can be performed. The Collections.synchronizedMap(Map) returns a SynchronizedMap backed by the original map. Every public method of the synchronized map are synchronized by a single private mutex. For example, here's the toString() method:

public String toString() {
    synchronized (mutex) {return m.toString();}
}

In order to guarantee serial access, it is critical that all access to the backing map is accomplished through the returned map.

Furthermore, manual synchronization may be necessary if you are, say iterating over the key set:

It is imperative that the user manually synchronize on the returned * map when iterating over any of its collection views... Failure to follow this advice may result in non-deterministic behavior.

Consider the following example:

//inside thread1
if(map.size()>n){
    //do something
    System.out.println(map.size());
}

//inside thread2
map.put(obj);

In this case, the value of map.size() in the if statement of thread1 will not necessarily be the equal to the printed value of map.size() inside the //do something block. In this case, you would have to manually synchronize on the map:

synchronize(map){
    if(map.size()>n){
        //do something
    }
}