并发利器--ConcurrentHashMap

ConcurrentHashMap和HashMap的结构差不多，因此在此不做过多的解释，如果不清楚HashMap的小伙伴，可以看我的另一篇文章《HashMap2》，本篇文章主要是围绕ConcurrentHashMap是如何保证线程安全的，至于其他的，在此处不会有过多的说明，好啦，我们进入正题吧：

我们知道HashMap是线程不安全的，会产生数据覆盖的问题，当我们在多线程的环境下，使用HashMap就不合适了，此时我们可以使用HashTable,Collections.synchronizedMap(new HashMap<String,String>())，或者是使用synchronized来保证线程安全。但是我们一般使用ConcurrentHashMap来保证线程安全。

以下ConcurrentHashMap的介绍基于JDK1.8+

ConcurrentHashMap实现线程安全的手段主要有2种方式：cas+synchronized。
以下是put方法的源码：
虽然里面只有几处使用了cas+synchronized,但是我还是把代码全部贴出来了，为了让大家更好的理解整个put流程。

   
   /**

先来说一下put的大致流程：
    1.首先判断这存放Node节点的table是否初始化了，如果没有初始化就先初始化，这个操作一般是第一次添加元素的时候会做的事情。
    2.根据 (n - 1) & hash计算出table上索引位置
    3.如果table上的这个索引位置为空，那么直接cas插入数据（防止数据覆盖）
    4.如果table上的这个索引位置不为空，则获取该节点的hash值，当hash值等于MOVED（-1）时，则说明当前table正在扩容，那么则复制到新的数组中
    5.如果以上4种情况都不满足，那么就使用synchronized进行加锁，将table中的节点取出来然后判断是红黑树还是链表进行添加节点操作。
             如果判断是链表：遍历整个链表，将取出的节点的key与要添加的节点key进行比较，如果相等，并且key的hash值也相等的话，那么就使用要添加节点的值覆盖原来的值，否则添加到链表末尾。
             如果判断是红黑树：则调用putTreeVal方法把这个元素添加到树中去
   6.添加完成之后需要判断，会判断该table的索引处有多少个节点（添加前的），如果大于8， 则调用treeifyBin方法来尝试将此处的链表转为树，或者扩容数组

*这里要说一下：链表转换成本红黑树的条件：链表的长度达到8，并且table的长度达到64。如果table的长度没有达到64，那么会触发扩容，而不会树化。



*/




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




    /** Implementation for put and putIfAbsent */
    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; K fk; V fv;
            if (tab == null || (n = tab.length) == 0)
                tab = initTable();
           //cas 原子操作  保证了多线程环境下不会发生数据覆盖
            else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
                if (casTabAt(tab, i, null, new Node<K,V>(hash, key, value)))
                    break;                   // no lock when adding to empty bin
            }
            else if ((fh = f.hash) == MOVED)
                tab = helpTransfer(tab, f);
            else if (onlyIfAbsent // check first node without acquiring lock
                     && fh == hash
                     && ((fk = f.key) == key || (fk != null && key.equals(fk)))
                     && (fv = f.val) != null)
                return fv;
            else {
                V oldVal = null;

               //加锁 保证了串行化操作，不会产生生线程安全问题
                synchronized (f) {
                //cas
                    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);
                                    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;
                            }
                        }
                        else if (f instanceof ReservationNode)
                            throw new IllegalStateException("Recursive update");
                    }
                }
                if (binCount != 0) {
                    if (binCount >= TREEIFY_THRESHOLD)
                        treeifyBin(tab, i);
                    if (oldVal != null)
                        return oldVal;
                    break;
                }
            }
        }
        addCount(1L, binCount);
        return null;
    }

要理解以上的cas操作，我们还必须看明白几个方法：

   //用来返回节点数组的指定位置的节点的原子操作
 @SuppressWarnings("unchecked")
    static final <K,V> Node<K,V> tabAt(Node<K,V>[] tab, int i) {
        return (Node<K,V>)U.getObjectAcquire(tab, ((long)i << ASHIFT) + ABASE);
    }

     //cas原子操作，在指定位置设定值
    static final <K,V> boolean casTabAt(Node<K,V>[] tab, int i,
                                        Node<K,V> c, Node<K,V> v) {
        return U.compareAndSetObject(tab, ((long)i << ASHIFT) + ABASE, c, v);
    }

     // 原子操作，在指定位置设定值
    static final <K,V> void setTabAt(Node<K,V>[] tab, int i, Node<K,V> v) {
        U.putObjectRelease(tab, ((long)i << ASHIFT) + ABASE, v);
    }

以上三个方法都是通过Unsafe这个类进行的cas原子操作。
可能有些才接触java的小伙伴，不清楚cas原子操作和Unsafe类，需要小伙伴们自己去查阅相关资料，不清楚没关系，不清楚才知道自己哪些欠缺嘛，多学习一点点，每天进步一点点，一年就进步365点点。
好啦，以上就是为什么ConcurrentHashMap是线程安全的基本原理了，又到了说再见的时候了。

作者感言：
写这篇文章的时候开始觉得无从下手，因为ConcurrentHashMap保证线程安全的原理其实就那么一点点:cas操作+synchronized,在代码里面也就那么几行，也没啥好说的，所以作者又把ConcurrentHashMap的put流程说了一遍，让小伙伴么能够更加清楚它是如何保证线程安全的，其实在我的另一篇HashMap2中已经说过一遍了。哎，一篇文章总的有点内容呀，为了让文章的内容比较丰满，我又在开始说废话凑字数了，嘿嘿嘿。下一篇文章正在酝酿中，小伙伴们有什么好的建议吗，欢迎留言哟…

创作不易，如果觉得好，请不要吝啬你们的大拇指，点个赞，嘿嘿嘿。！！！ 你们的给力，就是我的动力，我是爱生活的袁非非！！！