ConcurrentHashMap

ConcurrentHashMap implements the same functional specification as Hashtable/SynchronizedHashMap but it does not lock the whole hash table for read or update operations. ConcurrentHashMap maintains a hashtable that supports full concurrency of retrievals and high expected concurrency for updates.

Internal Implementation details of ConcurrentHashMap:

Hashtable has all the synchronized methods which results in locking of the table for other operations. But ConcurrentHashMap does not lock the whole table but only a certain part of the hash table and that only is locked for updates not for read/retrieval operations. And this way ConcurrentHashMap supports full concurrency for the read/retrieval operations. Even for updates operations, CoincurrentHashMap does not lock the complete table but only a part of the hash table. This way it provides high expected concurreny for update operations. Retrieval operations generally do not block, so may overlap with update operations. Retrievals reflect the results of the most recently completed update operations holding upon their onset. An update operation for a given key bears a happens-before relation with any retrieval for that key reporting the updated value.

Why ConcurrentHashMap :
A Map implementation class that provides the capability to support multiple threads concurrently. ConcurrentHashMap supports concurrent read and update operations.
ConcurrentHashMap supports full concurrency for the read/retrieval operations.
ConcurrentHashMap provides high expected concurreny for update operations. Update operation blocks a particular portion of the internal hash table.

Important ConcurrentHashMap Parameters :

Load factor is is a measure of how full the hash table is allowed to get before its capacity is automatically increased. Default load factor for concurrentHashMap is 0.75.

private static final float LOAD_FACTOR = 0.75f;

The default initial table capacity of a concurrentHashMap is 16 that is represented by the below field.

private static final int DEFAULT_CAPACITY = 16;

   public ConcurrentHashMap() {
    }

   
    public ConcurrentHashMap(int initialCapacity, float loadFactor) {
        this(initialCapacity, loadFactor, 1);
    }

    public ConcurrentHashMap(int initialCapacity,
                             float loadFactor, int concurrencyLevel) {
        if (!(loadFactor > 0.0f) || initialCapacity < 0 || concurrencyLevel <= 0)
            throw new IllegalArgumentException();
        if (initialCapacity < concurrencyLevel)   // Use at least as many bins
            initialCapacity = concurrencyLevel;   // as estimated threads
        long size = (long)(1.0 + (long)initialCapacity / loadFactor);
        int cap = (size >= (long)MAXIMUM_CAPACITY) ?
            MAXIMUM_CAPACITY : tableSizeFor((int)size);
        this.sizeCtl = cap;
    }

Resizing/Expanding the hash ConcurrentHashMap :

load factor is is a measure of how full the hash table is allowed to get before its capacity is automatically increased. Default load factor for concurrentHashMap is 0.75.

private static final float LOAD_FACTOR = 0.75f;

Constructors :

Default constructor which creates a new instance of ConcurrentHashMap with an empty map. Since we are not passing any parameter it takes the default values.

    public ConcurrentHashMap() {
    }

    public ConcurrentHashMap(int initialCapacity) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException();
        int cap = ((initialCapacity >= (MAXIMUM_CAPACITY >>> 1)) ?
                   MAXIMUM_CAPACITY :
                   tableSizeFor(initialCapacity + (initialCapacity >>> 1) + 1));
        this.sizeCtl = cap;
    }

    public ConcurrentHashMap(int initialCapacity, float loadFactor) {
        this(initialCapacity, loadFactor, 1);
    }

Adding key-value pair to ConcurrentHashMap using put() method :
To add a key-value pair to the ConcurrentHashMap, we pass key-value pair arguments to the put() method, which maps the specified key to the specified value in this table. Neither the key nor the value can be null.
ConcurrentHashMap throws NullPointerException if the specified key or value is null

 
    public V put(K key, V value) {
        return putVal(key, value, false);
    }

Here we pass the key - K var1 and value – V var2.

The put() method calls putVal() method internally.
putVal() takes the three arguments : key, value and onlyIfAbsent(boolean).

putVal() first check for the HashMap table and if the table is null or empty then calls the resize() method. putVal method :

    final V putVal(K key, V value, boolean onlyIfAbsent) {
        if (key == null || value == null) throw new NullPointerException();
        int hash = spread(key.hashCode());
        int binCount = 0;
        for (Node<K,V>[] tab = table;;) {
            Node<K,V> f; int n, i, fh;
            if (tab == null || (n = tab.length) == 0)
                tab = initTable();
            else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
                if (casTabAt(tab, i, null,
                             new Node<K,V>(hash, key, value, null)))
                    break;                   // no lock when adding to empty bin
            }
            else if ((fh = f.hash) == MOVED)
                tab = helpTransfer(tab, f);
            else {
                V oldVal = null;
                synchronized (f) {
                    if (tabAt(tab, i) == f) {
                        if (fh >= 0) {
                            binCount = 1;
                            for (Node<K,V> e = f;; ++binCount) {
                                K ek;
                                if (e.hash == hash &&
                                    ((ek = e.key) == key ||
                                     (ek != null && key.equals(ek)))) {
                                    oldVal = e.val;
                                    if (!onlyIfAbsent)
                                        e.val = value;
                                    break;
                                }
                                Node<K,V> pred = e;
                                if ((e = e.next) == null) {
                                    pred.next = new Node<K,V>(hash, key,
                                                              value, null);
                                    break;
                                }
                            }
                        }
                        else if (f instanceof TreeBin) {
                            Node<K,V> p;
                            binCount = 2;
                            if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
                                                           value)) != null) {
                                oldVal = p.val;
                                if (!onlyIfAbsent)
                                    p.val = value;
                            }
                        }
                    }
                }
                if (binCount != 0) {
                    if (binCount >= TREEIFY_THRESHOLD)
                        treeifyBin(tab, i);
                    if (oldVal != null)
                        return oldVal;
                    break;
                }
            }
        }
        addCount(1L, binCount);
        return null;
    }

if (key == null || value == null) 
	throw new NullPointerException();