Java并发分析—ConcurrentHashMap

　　LZ在 https://www.cnblogs.com/xyzyj/p/6696545.html 中简单介绍了List和Map中的常用集合，唯独没有CurrentHashMap。原因是CurrentHashMap太复杂了，于是新开一篇，将在这里将隆重介绍。

　　在java中，hashMap 和hashTable 与 currentHashMap 的关系比较密切，所以LZ在这多啰嗦一下，从hashMap，hashTable说起，再逐渐过渡到CurrentHashMap，以便于读者更能清晰地理解它的来龙去脉。

1.hashMap(JDK 1.7)

1.1 hashMap的数据结构图

　　大家都知道hashmap的数据结构是由数组+链表实现的，如图：

　　HashMap默认的初始化容量是16，默认加载因子是0.75。扩容就是把一原map结构中的数据一一取出来放在一个更大的map结构中，在操作链表时使用的是头插法。在单线程时，扩容是没有问题的，但是在多线程下，会发生线程安全问题。

1.2 HashMap扩容分析

　　扩容源码如下：

void transfer(Entry[] newTable) {
        Entry[] src = table;
        int newCapacity = newTable.length;
        for (int j = 0; j < src.length; j++) {
            Entry<K,V> e = src[j];
            if (e != null) {
                src[j] = null;
                do {
                    Entry<K,V> next = e.next;
                    int i = indexFor(e.hash, newCapacity);
                    e.next = newTable[i];
                    newTable[i] = e;
                    e = next;
                } while (e != null);
            }
        }
    }

　　其中最主要的是红色部分，把这几句代码摘出来，标上序号，方便后文引用，看下执行过程中会发生什么?

Entry<K,V> next = e.next;  ①
e.next = newTable[i];      ②
newTable[i] = e;           ③
e = next;                  ④

　　具体过程举一个例子：

　　单线程情况下的扩容情况：

　　

　　这是一个大小为2的map结构，其中在下标为1的数组上挂了一个长度为3的链表，链表中的3个key分别为 3,5,9 。而这三个key都是 mod(2) 以后放在链表中的。造成一个链过程。此时e节点指向了3，next节点指向了e的下一个节点 5 ，现在要将此map扩容，则将mod(2)变成mode(4)。单线程执行步骤如下：

（1）执行代码①②后结果：e指向了新map的3 ，e的next为空。

　　

（2）循环执行代码④①后的结果：e指向5，next执行9

　　

（3）继续循环执行，链表使用头插法，最终的结果如下：e指向了5，next指向了null，5和9的顺序发生了反转，和扩容完毕。

　　

　　在多线程下的扩容情况：

　　　

　　同样是上面的map结构。有两个线程A和线程B进行扩容，

（1）线程A执行代码①后挂起。此时线程A的指针情况如上图，e指向3，next指向5。

（2）此时线程B执行扩容，直至线程B扩容完毕，新的map结构如单线程中的执行结果：

　　

　　在这个时候，线程A开始执行，但线程A的指针还是挂起之前的状态，为了方便标识，下面用红色标识A线程，用绿色标识B线程。

　

　　如上图，线程A在挂起之前e指向3，next，指向5，并且这两个节点在原map上，当A挂起后，就像睡了一觉，这是线程B将原map结构上的节点复制到了新的mao结构上，当A醒来之后，它的e和next执行节点没变，但是节点的位置发生了变化，已经在新的map上了，因此会出现上图现象，此时A开始扩容：

（3）A执行②③代码，情况和上图一样，没有变化，依然是将3节点放在newtable[3]上。

（4）A循环执行④①代码，情况如下；

　　e = next；        ④        （3）执行完后的情况如上图，A的next执行 5，所以执行完这行代码后，e指向5。

　　next = e.next；①         执行完代码④后，e指向了5，而在e挂起之前，5的next指向了9，此时e的next为9，next = e.next = 9。

（5）A在执行②③代码后的情况如下：

e.next = newTable[i];      ②  此时e指向5，i等于1，e.next指向9 （线程B扩完容，9的next指向了5）
newTable[i] = e;           ③  此时，新table[1]指向e，即5

　　此时出现了环形循环，即死循环。。。

1.3 HashMap扩容时机

　　从上面知道了HashMap扩容原理，那么hashMap到底是什么时候扩容的呢？

　　上面提到过，HashMap默认的初始化容量是16，默认加载因子是0.75，什么意思呢？就是16*0.75 = 12，即当向hashMap中通过put()方法存入的数据大于12个的时候就会扩容，扩容后的容量为 16*2 = 32 ，举个简单的例子。

public static void main(String[] args) {
        Map map = new HashMap<Integer, Integer>();
        for(int i = 0;i < 12;i++){
            map.put(i, i+1);
        }
}

　　这是一个很简单的put(）操作，然后在扩容源码上打上断点，debug执行完成，没有任何拦截，过程不再演示，下面将for循环中的条件改成 i < 13,debug当put第13个键值对的时候，如下图：

　　　　

　　从上图可知，当put的键值对大于12的时候就会进行扩容。

2.hashMap(JDK 1.8)

　　在1.8中，对hashmap做了优化，在1.7中，有个很容易发生的问题，就是当发生hash冲突的概率比较高时，数组上的某个链表上的数据就会比较多，而其他链表上数据比较少，某个链表将变的非常长，导致查询效率降低。于是，在1.8中，当某个链表上的键值对个数达到8个时，就会将此链表转化为红黑树，我们知道，红黑树的查询效率非常高，主要是用它来存储有序的数据，它的时间复杂度是O(lgn)，java集合中的TreeSet和TreeMap以及linux虚拟内存管理就是用红黑树实现的。关于红黑树，这里不再介绍，可以参阅 http://www.360doc.com/content/18/0904/19/25944647_783893127.shtml 。下面看看hashmap的源码。

put()方法源码：

  /**
      * Implements Map.put and related methods
      *
      * @param hash hash for key
      * @param key the key
      * @param value the value to put
      * @param onlyIfAbsent if true, don't change existing value
      * @param evict if false, the table is in creation mode.
      * @return previous value, or null if none
      */
     final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                    boolean evict) {
         Node<K,V>[] tab; Node<K,V> p; int n, i;
         if ((tab = table) == null || (n = tab.length) == 0)
             n = (tab = resize()).length;
         if ((p = tab[i = (n - 1) & hash]) == null)
             tab[i] = newNode(hash, key, value, null);
         else {
             Node<K,V> e; K k;
             if (p.hash == hash &&
                 ((k = p.key) == key || (key != null && key.equals(k))))
                 e = p;
             else if (p instanceof TreeNode)
                 e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
             else {
                 for (int binCount = 0; ; ++binCount) {
                     if ((e = p.next) == null) {
                         p.next = newNode(hash, key, value, null);
                         if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                             treeifyBin(tab, hash);
                         break;
                     }
                     if (e.hash == hash &&
                         ((k = e.key) == key || (key != null && key.equals(k))))
                         break;
                     p = e;
                 }
             }
             if (e != null) { // existing mapping for key
                 V oldValue = e.value;
                 if (!onlyIfAbsent || oldValue == null)
                     e.value = value;
                 afterNodeAccess(e);
                 return oldValue;
             }
         }
         ++modCount;
         if (++size > threshold)
             resize();
         afterNodeInsertion(evict);
         return null;
     }

　　其中红色部分就是当链表上的键值对大于8时，将链表转化为红黑树。TREEIFY_THRESHOLD  的初始化值为8。

3.hashtable是线程安全且效率低的

　　hashTable其实和hashMap原理相似（1.7，1.8），不同点有四个：

　  （）.hashTable是线程安全而 HashMap不是线程安全的。

　　（）.HashTable不允许key和value为null 而 HashMap允许。

　　（）.hashtable初始化大小为11，默认加载因子为0.75，扩容后容量是原来的2倍+，而hashMap初始化容量大小为16，默认加载因子为0.75，
         扩容后的容量是原来的2倍。

   （4）.hashtable计算hash是直接使用key的hashcode对table数组的长度直接进行取模，hashmap计算hash对key的hashcode进行了二次hash，
         以获得更好的散列值，然后对table数组长度取摸

　　实现线程安全的方法则是使用synchronized关键字，下面看下hashtable部分源码：

public synchronized int size() {
    return count;
}

public synchronized V put(K key, V value) {
    // Make sure the value is not null
    if (value == null) {
        throw new NullPointerException();
    }

    // Makes sure the key is not already in the hashtable.
    Entry tab[] = table;
    int hash = key.hashCode();
    int index = (hash & 0x7FFFFFFF) % tab.length;
    for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) {
        if ((e.hash == hash) && e.key.equals(key)) {
        V old = e.value;
        e.value = value;
        return old;
        }
    }

    modCount++;
    if (count >= threshold) {
        // Rehash the table if the threshold is exceeded
        rehash();

            tab = table;
            index = (hash & 0x7FFFFFFF) % tab.length;
    }

    // Creates the new entry.
    Entry<K,V> e = tab[index];
    tab[index] = new Entry<K,V>(hash, key, value, e);
    count++;
    return null;
    }

　　可以看出，在源码中，在很多方法汇总都插入了synchronized关键在保证同步，因此，在扩容时，不会出现多个线程同一时间间隔内扩容，所以不会出现死循环。在LZ上篇文中（https://www.cnblogs.com/xyzyj/p/11148497.html）已经详细介绍了synchronized，它一次只允许一个线程执行锁中的代码，故而，hashtable是线程安全且效率低的。

　　HashMap中只有一条记录可以是一个空的key，但任意数量的条目可以是空的value。如果在表中没有发现搜索键，或者如果发现了搜索键，但它是一个空的值，那么get()将返回null。如果有必要，用containKey()方法来区别这两种情况。

　　为什么HashTable和ConcurrentHashMap都不允许key和value为null 而 HashMap允许？

　　网上找到的答案是这样的：ConcurrentHashmap和Hashtable都是支持并发的，这样会有一个问题，当你通过get(k)获取对应的value时，如果获取到的是null时，你无法判断，它是put（k,v）的时候value为null，还是这个key从来没有做过映射。HashMap是非并发的，可以通过contains(key)来做这个判断。而支持并发的Map在调用m.contains（key）和m.get(key),m可能已经不同了。

4.优秀的ConcurrentHashMap

　　在涉及到Java多线程开发时，如果我们使用HashMap可能会导致死锁问题，使用HashTable效率又不高。而ConcurrentHashMap既可以保持同步也可以提高并发效率，所以这个时候ConcurrentHashmap是我们最好的选择。

　　CurrentHashMap底层是一个复杂的数据结构，先看图。

　　

　　上图就是ConcurrenthashMap(1.8)的数据结构图，它是由Segment数组和hashMap组成的。其中每一个Segment都对应一个hashmap，由Segment，在jdk1.7中，ConcurrentHashMap使用的hashmap是jdk1.7中的hashMap，在jdk1.8中，ConcurrentHashMap使用的HashMap是jdk1.8中的hashMap，其原理类似，且Jdk1.7中的hashMap上文已经做过介绍，故，在此只介绍1,8中的ConcurrentHashMap。

　　ConcurrentHashMap的优点是使用了Segment数组，Segment数组的每一个元素对用一个hashmap。Segment继承了ReentrantLock ，使用ReentrantLock 对数组某些元素加锁，即只对部分hashMap加锁，从而实现了只对需要加锁的的某一段数进行加锁，实现了多线程并发的操作，这种加锁方式就是分段锁。

　　Segment继承了ReentrantLock的源码如下：

 /**
     * Stripped-down version of helper class used in previous version,
     * declared for the sake of serialization compatibility
     */
    static class Segment<K,V> extends ReentrantLock implements Serializable {
        private static final long serialVersionUID = 2249069246763182397L;
        final float loadFactor;
        Segment(float lf) { this.loadFactor = lf; }
    }

　　一些默认的参数：

/*
     * 最大可能的扩容数量为1 << 30，即2的30次方。
     * 说明：
     * 1.HashMap在确定数组下标Index的时候，采用的是( length-1) & hash的方式，
     *   只有当length为2的指数幂的时候才能较均匀的分布元素
     * 2.由于HashMap规定了其容量是2的n次方，所以我们采用位运算<<来控制HashMap的大小。
     * 使用位运算同时还提高了Java的处理速度。HashMap内部由Entry[]数组构成，
     * Java的数组下标是由Int表示的。所以对于HashMap来说其最大的容量应该是不超过int最大值的一个2的指数幂，
     * 而最接近int最大值的2个指数幂用位运算符表示就是 1 << 30
     */
    private static final int MAXIMUM_CAPACITY = 1 << 30;

    /*
     *  默认初始表容量。 必须是2的幂,（即至少为1）且最多为MAXIMUM_CAPACITY。
     *  所以HashMap规定了其容量必须是2的n次方
     */
    private static final int DEFAULT_CAPACITY = 16;

    /*
     * 最大可能（非幂2）阵列大小，需要使用toArray和相关方法。
     * MAX_VALUE = 0x7fffffff;
     * 数组作为一个对象，需要一定的内存存储对象头信息，对象头信息最大占用内存不可超过8字节
     */
    static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

    /*
     * 此表的默认并发级别。即Segment数组的大小，
     * 也就是默认会创建 16 个箱子，箱子的个数不能太多或太少。
     * 如果太少，很容易触发扩容，如果太多，遍历哈希表会比较慢。
     */
    private static final int DEFAULT_CONCURRENCY_LEVEL = 16;

    /*
     * 默认加载因子，
     * 当键值对的数量大于 16 * 0.75 = 12 时，就会触发扩容
     */
    private static final float LOAD_FACTOR = 0.75f;

    /*
     * 计数阈值,当链表中的数量大于等于8时，链表转化为红黑树
     * 因为红黑树需要的结点至少为8个
     */
    static final int TREEIFY_THRESHOLD = 8;

    /*
     * 在哈希表扩容时，如果发现链表长度小于 6，则会由树重新退化为链表
     */
    static final int UNTREEIFY_THRESHOLD = 6;

   /*
    * 在转变成树之前，会做一次判断，只有键值对数量大于 64 才会发生转换。
    * 这是为了避免在哈希表建立初期，多个键值对恰好被放入了同一个链表中而导致不必要的转化。
    */
    static final int MIN_TREEIFY_CAPACITY = 64;

　　ConcurrentHashMap和hashMap的原理类似，下面是一些重要的类：

Node：

static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        volatile V val;
        volatile Node<K,V> next;

        Node(int hash, K key, V val, Node<K,V> next) {
            this.hash = hash;
            this.key = key;
            this.val = val;
            this.next = next;
        }

Node类是构造链表或者红黑树的结点的类，主要包含key，value，hash和next。

TreeNode：

static final class TreeNode<K,V> extends Node<K,V> {
        TreeNode<K,V> parent;  // red-black tree links
        TreeNode<K,V> left;
        TreeNode<K,V> right;
        TreeNode<K,V> prev;    // needed to unlink next upon deletion
        boolean red;

        TreeNode(int hash, K key, V val, Node<K,V> next,
                 TreeNode<K,V> parent) {
            super(hash, key, val, next);
            this.parent = parent;
        }

        Node<K,V> find(int h, Object k) {
            return findTreeNode(h, k, null);
        }

        /**
         * 返回给定键的TreeNode（如果未找到，则返回null）
         * 从给定的根开始。
         */
        final TreeNode<K,V> findTreeNode(int h, Object k, Class<?> kc) {
            if (k != null) {
                TreeNode<K,V> p = this;
                do  {
                    int ph, dir; K pk; TreeNode<K,V> q;
                    TreeNode<K,V> pl = p.left, pr = p.right;
                    if ((ph = p.hash) > h)
                        p = pl;
                    else if (ph < h)
                        p = pr;
                    else if ((pk = p.key) == k || (pk != null && k.equals(pk)))
                        return p;
                    else if (pl == null)
                        p = pr;
                    else if (pr == null)
                        p = pl;
                    else if ((kc != null ||
                              (kc = comparableClassFor(k)) != null) &&
                             (dir = compareComparables(kc, k, pk)) != 0)
                        p = (dir < 0) ? pl : pr;
                    else if ((q = pr.findTreeNode(h, k, kc)) != null)
                        return q;
                    else
                        p = pl;
                } while (p != null);
            }
            return null;
        }
    }

TreeNode类是对红黑树的描述，主要方法是返回给定键的TreeNode。
再看put方法：

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();
            //找到具体的数组下标，如果此位置没有值，那么直接初始化一下 Node ,并把值放在这个位置
            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)
                        //如果结点个数大于等于8，则转化为红黑树
                        treeifyBin(tab, i);
                    if (oldVal != null)
                        return oldVal;
                    break;
                }
            }
        }
        addCount(1L, binCount);
        return null;
    }

参考资料：

https://blog.csdn.net/qq_33296156/article/details/82428026