并发包里面ConcurrentHashMap是一个使用频率，面试频率都是用到比较高的。今天我们就剖析一下ConCurrentHashMap的源码。我们还是使用场景驱动的方式去分析。

1. 构建函数

        但是发现构造函数进去以后就是一个无参的构造，没什么特别的。

    2.分析put流程

        put流程是整个ConCurrentHashMap的精华部分,里面淋漓尽致的使用了分段加锁的思想。

    3.分析get流程

     Get是一个读流程，采用的也是无锁化方式，但是方法调的底层的unsafe的方法保证了可见性。整个ConCurrentHashMap的性能很高。

ConcurrentHashMap
    
      map = new ConcurrentHashMap
     
      ();//剖析写数据流程map.put("test","zhangsan");//剖析读数据流程map.get("test")接着我们分析一下put的方法，这个方法非常重要。体现了整个ConCurrentHashMap的设计精髓。Put点进去以后是这个方法public V put(K key, V value) {//重要，点进去以后继续分析    return putVal(key, value, false);}final V putVal(K key, V value, boolean onlyIfAbsent) {//如果key或者value其中一个null，就报空指针异常    if (key == null || value == null) throw new NullPointerException();//取hash值，但是我们注意的是，这儿并不是直接用的key的hashCode值。//而是调用了spred方法。//spread里的关键代码是(h ^ (h >>> 16)) & HASH_BITS;//用当前的hashCode值向右移了16位，然后再做异或//这样操作的出来的值都保留着着hashCode的高低16位的特征，减少hash冲突//所以我们这儿要知道。这儿的hash值不是直接用的hashCode    int hash = spread(key.hashCode());    int binCount = 0;    for (Node
      
       [] tab = table;;) {        Node
       
         f; int n, i, fh;//如果当前的tab里面没有数据        if (tab == null || (n = tab.length) == 0)//初始化table,然后进去下一轮循环            tab = initTable();//进入下一轮循环以后走到这儿。//return (Node
        
         )U.getObjectVolatile(tab, ((long)i << ASHIFT) + ABASE);//这儿就是计算index的位置，使用tabAt的方法查找对应位置的数据//如果对应位置的数据是null，说明我们要插入的这个位置目前还没有数据//注意这儿使用的是unsafe的getObjectVolatile，也就是说，这个是具有可见性的//如果并发的时候有人修改了这个值，对这个操作也是课件。//如果有同学看过我之前分析过《从硬件层面聊聊synchonzied和volatile》//应该知道volatile这儿相当于是加了load屏障，在获取数据的时候，如果在无效队列里面发//现数据无效，就会重新加载。        else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {//如果当前位置没有元素，直接就通过cas进行插入元素。//cas操作的代码是//return U.compareAndSwapObject(tab, ((long)i << ASHIFT) + ABASE, c, v);//其实这个cas操作在硬件层面是加锁的，所以这儿其实是线程安全的。这点大家一定//要知道。//那么这儿我们还可以继续分析一下，如果这儿同时两个线程并发进来操作//必然有一个成功的，一个是失败了，成功的，当然就添加了数据了。//其实这个地方分段加锁的思想已经出来了，因为我们分析指导//针对表的一个位置，我们采用的cas的机制，这个时候，只有针对同一个位置//才会插入失败。但是其余的位置照样可以进行cas的操作。换句话说一个位置一把锁//因为是for循环，所以失败了的那个肯定再次循环。//但是因为这个位置已经有数据了。所以代码不走这儿了。            if (casTabAt(tab, i, null,                         new Node
         
          (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;//如果是针对同一个位置插入数据，那么代码就会走到这儿//走到这儿就直接加了一把锁，而这个锁就是针对这个位置的node//其实这儿也就体现了分段加锁的思想。一个Node就一把锁 synchronized (f) { //f其实就是前面要加锁的时候，获取出来的node //其实如果代码走到这儿，代表的就是tabAt(tab, i) == f //但是这儿还要继续判断就是为了一个严谨 //因为就怕中间有人修改过这个f这个node if (tabAt(tab, i) == f) { if (fh >= 0) { binCount = 1; for (Node
          
            e = f;; ++binCount) { K ek;//如果插入的key和value//key是一样的并且value不为空 if (e.hash == hash && ((ek = e.key) == key || (ek != null && key.equals(ek)))) { oldVal = e.val;//直接就覆盖 if (!onlyIfAbsent) e.val = value; break; }//代码走到这儿，只能说明是//key不一样，只不过是巧了，虽然key不一样//但是经过hash运算以后，当前key定位了一个//已经有数据的位置上。 Node
           
             pred = e; if ((e = e.next) == null) {//直接就在当前node上挂载 一个node节点//注意，一个节点上挂载的节点超过8个//就会变化为红黑树 pred.next = new Node
            
             (hash, key, value, null);//挂载成功以后就退出 break; } } }//如果当前定位到的Node已经变成是红黑树//那么就选择使用红黑树的方式插入数据 else if (f instanceof TreeBin) { Node
             
               p; binCount = 2; if ((p = ((TreeBin
              
               )f).putTreeVal(hash, key, value)) != null) { oldVal = p.val; if (!onlyIfAbsent) p.val = value; } } } } if (binCount != 0) {//如果是散列表上面挂了8个以上的节点//那么就把当前列表变成红黑树，提升查询效率 if (binCount >= TREEIFY_THRESHOLD)//变成红黑树 treeifyBin(tab, i); if (oldVal != null) return oldVal; break; } } }//计算node上挂载的节点个数 addCount(1L, binCount); return null;}private final Node
               
                [] initTable() { Node
                
                 [] tab; int sc; while ((tab = table) == null || tab.length == 0) { if ((sc = sizeCtl) < 0) Thread.yield(); // lost initialization race; just spin else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) { try { if ((tab = table) == null || tab.length == 0) { int n = (sc > 0) ? sc : DEFAULT_CAPACITY; @SuppressWarnings("unchecked") Node
                 
                  [] nt = (Node
                  
                   [])new Node
                   [n]; table = tab = nt; sc = n - (n >>> 2); } } finally { sizeCtl = sc; } break; } } return tab;}上面我们分析了写入数据的时候加锁的思想，接下来我们分析一下，ConcurrentHashMap读数据的时候又是什么情况？public V get(Object key) { Node
                   
                    [] tab; Node
                    
                      e, p; int n, eh; K ek; //计算位置int h = spread(key.hashCode());//这个条件判断，如果table里是有数据的，并且根据当前//key计算出来的位置也是有数据的 if ((tab = table) != null && (n = tab.length) > 0 && (e = tabAt(tab, (n - 1) & h)) != null) { //如果是hash值相同if ((eh = e.hash) == h) {//如果是key相同 if ((ek = e.key) == key || (ek != null && key.equals(ek))) //那么我们直接返回当前的value值就行。return e.val; } else if (eh < 0) return (p = e.find(h, key)) != null ? p.val : null;//如果代码走到这儿说明，要获取的key的对应//hash位置确实是有数据的，对应位置的key跟传//进来的key位置不一样,所以遍历列表 while ((e = e.next) != null) {//直到遍历到 hash位置一样，key也一样位置。//然后就把当前value值返回即可。 if (e.hash == h && ((ek = e.key) == key || (ek != null && key.equals(ek)))) return e.val; } } return null;}整个读的操作，我们分析其实是都没有加锁的。不过我们注意到map里的元素我们是靠tabAt(tab, (n - 1) & h)这个方法获取到的。static final 
                     
                       Node
                      
                        tabAt(Node
                       
                        [] tab, int i) {//调用了Unsafe的方法//还保证了可见性。 return (Node
                        
                         )U.getObjectVolatile(tab, ((long)i << ASHIFT) + ABASE);}
                        
                       
                      
                     
                    
                   
                  
                 
                
               
              
             
            
           
          
         
        
       
      
     
    

读这个操作保证了可见性，从硬件层面说，就是加了load屏障。所以在读数据的时候一定会嗅探一下，如果发现无效队列里面元素被人修改过。就会发送read消息到总线。从别的高速缓存里或者是主内存里读取数据。不加锁，但是他通过volatile读，尽可能给你保证读到其他线程修改的最新的值。