concurrentHashMap putIfAbsent method functionality

concurrenthashmap, java

Solution

A `ConcurrentHashMap` is designed so that it can be used by a large number of concurrent `Thread`s.

Now, if you used the methods provided by the standard `Map` interface you would probably write something like this

  if(!map.containsKey("something")) {
      map.put("something", "a value");
  }

This looks good and seems to do the job but, it is not thread safe. So you would then think, "Ah, but I know about the `synchronized` keyword" and change it to this

  synchronized(map) {
      if(!map.containsKey("something")) {
          map.put("something", "a value");
      }
  }

Which fixes the issue.

Now what you have done is locked the entire map for both read and write while you check if the key exists and then add it to the map.

This is a very crude solution. Now you could implement your own solution with double checked locks and re-locking on the key etc. but that is a lot of very complicated code that is very prone to bugs.

So, instead you use the solution provided by the JDK.

The `ConcurrentHashMap` is a clever implementation that divides the `Map` into regions and locks them individually so that you can have concurrent, thread safe, reads and writes of the map without external locking.

Like all other methods in the implementation `putIfAbsent` locks the key's region and not the whole `Map` and therefore allows other things to go on in other regions in the meantime.

Problem

I am a newbie to the world of Java and exploring the `concurrentHashMap`, while exploring the `concurrentHashMap` API , I discover the `putifAbsent()` method ``` public V putIfAbsent(K paramK, V paramV) { if (paramV == null) throw new NullPointerException(); int i = hash(paramK.hashCode()); return segmentFor(i).put(paramK, i, paramV, true); } ``` Now please advise what is it functionality and when do we practically require it , if possible please explain with a small simple example.

Original source