initTable方法

    1. //Initializes table, using the size recorded in sizeCtl.
    2. private final Node<K,V>[] initTable() {
    3.         Node<K,V>[] tab; int sc;
    4.         while ((tab = table) == null || tab.length == 0) {
    5.             if ((sc = sizeCtl) < 0)
    6.                 Thread.yield(); // lost initialization race; just spin
    7.             else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
    8.                 try {
    9.                     if ((tab = table) == null || tab.length == 0) {
    10.                         int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
    11.                         @SuppressWarnings("unchecked")
    12.                         Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
    13.                         table = tab = nt;
    14.                         //相当于0.75的负载系数 ，所以此时sc代表？
    15.                         sc = n - (n >>> 2);
    16.                     }
    17.                 } finally {
    18.                     sizeCtl = sc;
    19.                 }
    20.                 break;
    21.             }
    22.         }
    23.         return tab;
    24.     }

    里面需要注意的是变量 sizeCtl ，它的值决定着当前的初始化状态。 还要再理解下 -1 说明正在初始化 -N 说明有N-1个线程正在进行扩容 表示 table 初始化大小，如果 table 没有初始化 表示 table 容量 * 0.75，如果 table　已经初始化。

    put 方法：

    2.     /** Implementation for put and putIfAbsent */
    3.     final V putVal(K key, V value, boolean onlyIfAbsent) {
    4.         if (key == null || value == null) throw new NullPointerException();
    5.         int hash = spread(key.hashCode());
    6.         int binCount = 0;
    7.         //CAS经典写法，不成功无限重试，让再次进行循环进行相应操作。
    8.         for (Node<K,V>[] tab = table;;) {
    9.             // fh 后面存放目标位置的元素 hash 值(fh = f.hash))
    10.             Node<K,V> f; int n, i, fh;
    11.             if (tab == null || (n = tab.length) == 0)
    12.                 // 数组桶为空，初始化数组桶（自旋+CAS)
    13.                 tab = initTable();
    14.             else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
    15.              // 桶内为空，CAS 放入，不加锁，成功了就直接 break 跳出
    16.                 if (casTabAt(tab, i, null,
    17.                              new Node<K,V>(hash, key, value, null)))
    18.                     break;                   // no lock when adding to empty bin
    19.             }
    20.             else if ((fh = f.hash) == MOVED)
    21.                 //当前结点正在扩容，让当前线程调用helpTransfer也参与到扩容过程中来，扩容完毕后tab指向新table。
    22.                 tab = helpTransfer(tab, f);
    23.             else {
    24.                 V oldVal = null;
    25.                 // 使用 synchronized 加锁加入节点
    26.                 synchronized (f) {
    27.                     if (tabAt(tab, i) == f) {
    28.                          // 说明是链表
    29.                         if (fh >= 0) {
    30.                             binCount = 1;
    31.                             // 循环加入新的或者覆盖节点
    32.                             for (Node<K,V> e = f;; ++binCount) {
    33.                                 K ek;
    34.                                 if (e.hash == hash &&
    35.                                     ((ek = e.key) == key ||
    36.                                      (ek != null && key.equals(ek)))) {
    37.                                     oldVal = e.val;
    38.                                     if (!onlyIfAbsent)
    39.                                         e.val = value;
    40.                                     break;
    41.                                 }
    42.                                 Node<K,V> pred = e;
    43.                                 if ((e = e.next) == null) {
    44.                                     pred.next = new Node<K,V>(hash, key,
    45.                                                               value, null);
    46.                                     break;
    47.                                 }
    48.                             }
    49.                         }
    50.                         else if (f instanceof TreeBin) {
    51.                              // 红黑树
    52.                             Node<K,V> p;
    53.                             binCount = 2;
    54.                             if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
    55.                                                            value)) != null) {
    56.                                 oldVal = p.val;
    57.                                 if (!onlyIfAbsent)
    58.                                     p.val = value;
    59.                             }
    60.                         }
    61.                     }
    62.                 }
    63.                 if (binCount != 0) {
    64.                     //如果数量大于 TREEIFY_THRESHOLD 则要转换为红黑树
    65.                     if (binCount >= TREEIFY_THRESHOLD)
    66.                         treeifyBin(tab, i);
    67.                     if (oldVal != null)
    68.                         return oldVal;
    69.                     break;
    70.                 }
    71.             }
    72.         }
    73.         ////更新size，检测扩容
    74.         addCount(1L, binCount);
    75.         return null;
    76.     }

    参考: 关于jdk1.8中ConcurrentHashMap的方方面面
    HashMap? ConcurrentHashMap? 相信看完这篇没人能难住你！

    Java7 中 ConcruuentHashMap 使用的分段锁，也就是每一个 Segment 上同时只有一个线程可以操作，每一个 Segment 都是一个类似 HashMap 数组的结构，它可以扩容，它的冲突会转化为链表。但是 Segment 的个数一但初始化就不能改变。

    Java8 中的 ConcruuentHashMap 使用的 Synchronized 锁加 CAS 的机制。结构也由 Java7 中的 Segment 数组 + HashEntry 数组 + 链表 进化成了 Node 数组 + 链表 / 红黑树，Node 是类似于一个 HashEntry 的结构。它的冲突再达到一定大小时会转化成红黑树，在冲突小于一定数量时又退回链表。

    有些同学可能对 Synchronized 的性能存在疑问，其实 Synchronized 锁自从引入锁升级策略后，性能不再是问题，有兴趣的同学可以自己了解下 Synchronized 的锁升级。