原子地执行多个操作

Question

I'm trying to find a way to perform multiple operations on a ConcurrentHashMap in an atomic manner.

My logic is like this:

if (!map.contains(key)) {
    map.put(key, value);

    doSomethingElse();
}

I know there is the putIfAbsent method. But if I use it, I still won't be able to call the doSomethingElse atomically.

Is there any way of doing such things apart from resorting to synchronization / client-side locking?

If it helps, the doSomethingElse in my case would be pretty complex, involving creating and starting a thread that looks for the key that we just added to the map.

Answer 1

If it helps, the doSomethingElse in my case would be pretty complex, involving creating and starting a thread that looks for the key that we just added to the map.

If that's the case, you would generally have to synchronize externally.

In some circumstances (depending on what doSomethingElse() expects the state of the map to be, and what the other threads might do the map), the following may also work:

if (map.putIfAbsent(key, value) == null) {
    doSomethingElse();
}

This will ensure that only one thread goes into doSomethingElse() for any given key.

Answer 2

This would work unless you want all putting threads to wait until the first successful thread puts in the map..

if(map.get(key) == null){

  Object ret = map.putIfAbsent(key,value);
  if(ret == null){ // I won the put
     doSomethingElse();
  }
}

Now if many threads are putting with the same key only one will win and only one will doSomethingElse() .

Answer 3

If your design demands that the map access and the other operation be grouped without anybody else accessing the map, then you have no choice but to lock them. Perhaps the design can be revisited to avoid this need?

This also implies that all other accesses to the map must be serialized behind the same lock.

Answer 4

You might keep a lock per entry. That would allow concurrent non-locking updates, unless two threads try to access the same element.

class LockedReference<T> {
  Lock lock = new ReentrantLock();;
  T value;
  LockedReference(T value) {this.value=value;}      
}

LockedReference<T> ref = new LockedReference(value);
ref.lock.lock(); //lock on the new reference, there is no contention here
try {
  if (map.putIfAbsent(key, ref)==null) {
    //we have locked on the key before inserting the element
    doSomethingElse();
   }
} finally {ref.lock.unlock();}

later

Object value;
while (true) {
   LockedReference<T> ref = map.get(key)
   if (ref!=null) {
      ref.lock.lock(); 
      //there is no contention, unless a thread is already working on this entry
      try {
         if (map.containsKey(key)) {
          value=ref.value;
          break;      
         } else {
          /*key was removed between get and lock*/
         }
      } finally {ref.lock.unlock();} 
   } else value=null;
}  

A fancier approach would be rewriting ConcurrentHashMap and have a version of putIfAbsent that accepts a Runnable (which is executed if the element was put). But that would be far far more complex.

Basically, ConcurrentHashMap implements locked segments, which is in the middle between one lock per entry, and one global lock for the whole map.