Great Deals

Showing posts with label java interview questions. Show all posts

ConcurrentHashMap in nutshell

The Java concurrent hash map may be considered as the lodge having many rooms with locking facility.Where as hash map may be considered as the house with one door.

 So in case of hash map if you are locking the door. Then you will not be able to access if any of the room of house. Before using hash map every thread locks the hash map making it inaccessible to other thread till the  time it won't complete it's operations. 
Hashmap is like your house
Hashmap

But if concurrent hash map is viewed it may be viewed as multiple separate rooms of Lodge if any room is locked we can still access the other rooms.

Concurrent hashmap used by multiple thread

Creation of ConcurrentHashMap


public ConcurrentHashMap(int initialCapacity,float loadFactor, int concurrencyLevel) 

HashMap anatomy:



Initial Capacity: 

You can specify the size of the concurrenthashmap at the time of creation.


 static final int DEFAULT_INITIAL_CAPACITY = 16;

Load Factor: 

Tolerable capacity of concurrenthashmap if it exceeds concurrenthashmap needs to be resized. However resizing operation is relatively slow.

 static final float DEFAULT_LOAD_FACTOR = 0.75f;

ConcurrencyLevel:

Estimated number of concurrently updated threads.

Advantages of concurrenthashmap:


ConcurrentHashMap can be used to make the concurrent operations possible without waiting for other threads job completion

Increased throughput.

For Producer Consumer Example on concurrenthashmap Producer Consumer in ConcurrentHashmap

Disadvantages of concurrency in hashmap


           Methods including size, isEmpty, and containsValue are typically useful only when a map is not undergoing concurrent updates in other threads. Otherwise these methods procure precise results.

When resizing is done?

1.       
       When the concurrenthashmap is almost full 75% of its defined capacity.
2.       When collisions are increased so to avoid collisions concurrenthashmap  is resized.

Properties of ConcurrentHashmap

1.      

         ConcurrentHashmap does not allow null value.
2.       ConcurrentHashMap does not allow duplicate keys.

public class CHashMap {

            public static void main(String[] args) {
ConcurrentHashMap<String, String> ch=new ConcurrentHashMap<String, String>();
ch.put("a", "a");
ch.put("a", "a");
Enumeration<String> enum1=ch.keys();

while(enum1.hasMoreElements())
{
            String key=enum1.nextElement();
            System.out.println("Key is ==>"+key+" Value is ===>"+ch.get(key));
            }
            }

}

Output is: Key is ==>a Value is ===>a

Concurrenthashmap Example

Concurrent HashMap example:


Concurrent HashMap works on the principle of concurrent access of the segment of hashmap.
It partially locks the map which gives better performance.
See the simple example where producer keeps adding the element.

  Producing the Element and pushing it in hashmap
 public void addValue()
            {
                        for(int i=0;i<100;i++)
                        {
                                   
                                    Integer intObj=new Integer(i);
                                    System.out.println(Thread.currentThread().getName()+"Producing "+intObj);
                                    this.st.put(intObj, intObj);
                        }

            }

Producer Code:


import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;
class Producer implements Runnable
{
            void init(ConcurrentHashMap<Integer,Integer> st)
            {
                        this.st=st;
            }
            ConcurrentHashMap<Integer,Integer> st;
            public void addValue()
            {
                        for(int i=0;i<100;i++)
                        {
                                   
                                    Integer intObj=new Integer(i);
                                    System.out.println(Thread.currentThread().getName()+"Producing "+intObj);
                                    this.st.put(intObj, intObj);
                        }
            }
           
            @Override
            public void run() {
                       
                        addValue();
            }
           
}


Consumer



Consumer part:
Consumer keeps on utilizing whatever is present in the hashmap. While producing or retrieving we did not encounter ConcurrentModificationException  example.
How to create Consumer code we will use get() that will be called by Thread Object.
   public void getValue()
            {
                       
                        for(int i=0;i<100;i++)
                        {
                                   
                                    System.out.println(Thread.currentThread().getName()+ "Consuming "+this.st.get(i));
                        }

            }


 class Consumer implements Runnable
{
            void init(ConcurrentHashMap<Integer,Integer> st)
            {
                        this.st=st;
            }
            ConcurrentHashMap<Integer,Integer> st;
           
            public void getValue()
            {
                       
                        for(int i=0;i<100;i++)
                        {
                                   
                                    System.out.println(Thread.currentThread().getName()+ "Consuming "+this.st.get(i));
                        }
            }
            @Override
            public void run() {
                       
                        getValue();
            }
           
}

Test Main:


public class HelloWorld{

     public static void main(String []args){
             ConcurrentHashMap<Integer,Integer> st=new ConcurrentHashMap<Integer, Integer>();
             Producer hashObj=new Producer();
             hashObj.init(st);
             Thread t2=new Thread(hashObj);
             t2.setName("t2  ");
         t2.start();
         Thread t3=new Thread(hashObj);
         t3.start();
         t2.setName("t3  ");
         try {
                                    t2.join();
                        } catch (InterruptedException e) {
                                    // TODO Auto-generated catch block
                                    e.printStackTrace();
                        }
         try {
                                    t3.join();
                        } catch (InterruptedException e) {
                                    // TODO Auto-generated catch block
                                    e.printStackTrace();
                        }
         Consumer consumeObj=new Consumer();
         consumeObj.init(st);
       Thread t1=new Thread(consumeObj);
       t1.setName("t1  ");
       t1.start();
      
     }
 }
Thank you for being kind enough to visit here.
If you really like this post you can boost my energy bar by pressing  Like Share :)
Subscribe to: Posts (Atom)

Advertising

Advertising