在多线程环境下，HashMap不符合使用场景，因为不是线程安全的，而如果使用Collections.synchronizedMap()来产生的Map又是一个使用全局锁来进行同步不同线程
之间的并发访问，效率和性能都不高。
这时候就有了HashMap的线程安全版 - ConcurrentHashMap。
ConcurrentHashMap 底层使用 数组 + 链表或者红黑树 来实现。
无论是读操作还是写操作性能都很高，读操作时几乎不加锁，写操作时又只对一个链表或者红黑树
进行加锁，不会对其他链表或者红黑树产生影响，即可以同时访问数组的各个链表或者红黑树。

jdk1.7之前和1.8之后实现方式不一样。
1.7之前实现数组+链表，put的时候锁住数组的一段，按一段段的锁，即一段可能包含几个链表。
1.8之后实现是数组 + 链表或者红黑树， put的时候锁住的数组的每一个元素，即每一个链表一个锁。
使用node + CAS + synchronized 来实现并发的put操作

其中不管是HashMap还是ConcurrentHashMap，1.7之前插入元素都是头插（即插入链表头部），
1.8之后都是尾插（链表尾部）。因为使用头插法时可能发生逆序并形成环形链表死循环。

ConcurrentHashMap 默认数组大小为16。

put 操作

ConcurrentHashMap 不允许key 或者value 为null

 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;
    }

1.首先根据key获得hash值
2.如果数组为null或者数组大小为0，则进行数组初始化，默认数组大小为16，
只能由一条线程来进行初始化数组
3.根据hash值找到在数组中对应的链表，如果链表为null，则以CAS方式插入链表
4.如果链表不为null，为两种情况。一种是当前处于移动状态，即正在扩容，则当前线程去帮忙扩容。
否则以synchronized锁住当前链表。如果hash值大于0，则遍历链表更新节点或者在尾部插入节点，
如果当前链表节点是树节点，说明是红黑树，调用putTreeVal 方法往红黑树中插入节点

5.其中有一局部变量binCount记录当前链表节点数量，如果节点是树节点，则为2。
在将元素插入链表后，会判断binCount是否大于阈值8，如果大于8，则将链表转为红黑树。

6.在链表符合转为红黑树条件的时候（即链表节点数量大于8），会先判断数组大小是否小于64。
如果小于64，则将当前数组扩大1倍，变为原来大小的两倍。
if ((n = tab.length) < MIN_TREEIFY_CAPACITY) 这一句

 private final void treeifyBin(Node<K,V>[] tab, int index) {
        Node<K,V> b; int n, sc;
        if (tab != null) {
            if ((n = tab.length) < MIN_TREEIFY_CAPACITY)
                tryPresize(n << 1);
            else if ((b = tabAt(tab, index)) != null && b.hash >= 0) {
                synchronized (b) {

get 操作

  public V get(Object key) {
        Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
        int h = spread(key.hashCode());
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (e = tabAt(tab, (n - 1) & h)) != null) {
            if ((eh = e.hash) == h) {
                if ((ek = e.key) == key || (ek != null && key.equals(ek)))
                    return e.val;
            }
            else if (eh < 0)
                return (p = e.find(h, key)) != null ? p.val : null;
            while ((e = e.next) != null) {
                if (e.hash == h &&
                    ((ek = e.key) == key || (ek != null && key.equals(ek))))
                    return e.val;
            }
        }
        return null;
    }

1.先根据key获得hash值
2.根据hash值获得在数组中链表，如果链表为null，直接返回null
3.链表不为null时，判断hash值，如果链表首节点符合，则返回对应value值。
如果链表首节点hash值小于0，说明正在扩容，则调用扩容节点的find方法，查找节点。
hash值大于0，则从首节点开始遍历节点，匹配则返回，否则返回null。

tryPresize 扩容方法

扩容大小必须为2的n次方，这个是因为和扩容后元素在数组中的链表位置相关。
扩容后的每个链表的元素的位置，要么不变，要么是原table索引位置+原table的容量大小。
例如三个元素（2,5,7）要放入map里面，table的的容量是2，
简单的假设元素位置=元素的值 % 数组容量 = 元素的值 % 2
得到

[0]=2  
[1]=5->7  

现在数组扩容为为4，得到

[0]=null 
[1]=5 
[2]=2
[3]=7

符合这个要求（扩容后的每个链表的元素的位置，要么不变，要么是原table索引位置+原table的容量大小）
所以数组不管在扩容前还是扩容后都能通过 元素hash值 % 数组容量 拿到元素正确的位置。

ps： 不管ConcurrentHashMap还是HashMap，
在将链表转为树或者新增数组链表节点的时候都有可能触发扩容

  private final void tryPresize(int size) {
      int c = (size >= (MAXIMUM_CAPACITY >>> 1)) ? MAXIMUM_CAPACITY :
          tableSizeFor(size + (size >>> 1) + 1);
      int sc;