ConcurrentHashMap 在JDK8中进行了巨大改动，它摒弃了 Segment （锁段）的概念，而是利用 CAS 算法和 synchronized 关键字来实现。它沿用了与它同时期的 HashMap 版本的思想，底层依然由 数组+链表+红黑树的方式思想(JDK7与JDK8中 HashMap 的实现)，但是为了做到并发，又增加了很多辅助的类，例如 TreeBin ， Traverser 等对象内部类。

jdk1.8concurrenthashmap.png

put 方法

源码

  1.     public V put(K key, V value) {
  2.         return putVal(key, value, false);
  3.     }
  5.     final V putVal(K key, V value, boolean onlyIfAbsent) {
  6.         // 不允许 key或value为null
  7.         if (key == null || value == null) throw new NullPointerException();
  8.         // 计算hash值
  9.         int hash = spread(key.hashCode());
  10.         int binCount = 0;
  11.         // 死循环 何时插入成功 何时跳出
  12.         for (Node<K,V>[] tab = table;;) {
  13.             Node<K,V> f; int n, i, fh;
  14.             //如果hash表为空的话，初始化hash表
  15.             if (tab == null || (n = tab.length) == 0)
  16.                 tab = initTable();
  17.             // /根据hash值计算出值在hash表里面的位置 
  18.             else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
  19.                 // 如果这个位置没有值 ，直接放进去，不需要加锁
  20.                 if (casTabAt(tab, i, null,
  21.                              new Node<K,V>(hash, key, value, null)))
  22.                     break;                   // no lock when adding to empty bin
  23.             }
  24.             // 当遇到表连接点时，进行扩容
  25.             else if ((fh = f.hash) == MOVED)
  26.                 tab = helpTransfer(tab, f);
  27.             else {
  28.                 V oldVal = null;
  29.                 //结点上锁  这里的结点可以理解为hash值相同组成的链表的头结点
  30.                 synchronized (f) {
  31.                     if (tabAt(tab, i) == f) {
  32.                         // fh〉0 说明这个节点是一个链表的节点 不是树的节点
  33.                         if (fh >= 0) {
  34.                             binCount = 1;
  35.                             // 在这里遍历链表所有的结点
  36.                             for (Node<K,V> e = f;; ++binCount) {
  37.                                 K ek;
  38.                                 // 如果hash值和key值相同  则修改对应结点的value值
  39.                                 if (e.hash == hash &&
  40.                                     ((ek = e.key) == key ||
  41.                                      (ek != null && key.equals(ek)))) {
  42.                                     oldVal = e.val;
  43.                                     if (!onlyIfAbsent)
  44.                                         e.val = value;
  45.                                     break;
  46.                                 }
  47.                                 Node<K,V> pred = e;
  48.                                // 遍历到了最后一个结点，证明新的节点需要插入 
  49.                                // 就把它插入在链表尾部
  50.                                 if ((e = e.next) == null) {
  51.                                     pred.next = new Node<K,V>(hash, key,
  52.                                                               value, null);
  53.                                     break;
  54.                                 }
  55.                             }
  56.                         }
  57.                         // 如果这个节点是树节点，就按照树的方式插入值
  58.                         else if (f instanceof TreeBin) {
  59.                             Node<K,V> p;
  60.                             binCount = 2;
  61.                             if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
  62.                                                            value)) != null) {
  63.                                 oldVal = p.val;
  64.                                 if (!onlyIfAbsent)
  65.                                     p.val = value;
  66.                             }
  67.                         }
  68.                     }
  69.                 }
  70.                 if (binCount != 0) {
  71.                     // 如果链表长度已经达到临界值8 就需要把链表转换为红黑树
  72.                     if (binCount >= TREEIFY_THRESHOLD)
  73.                         treeifyBin(tab, i);
  74.                     if (oldVal != null)
  75.                         return oldVal;
  76.                     break;
  77.                 }
  78.             }
  79.         }
  80.         addCount(1L, binCount);
  81.         return null;
  82.     }

扩容

  1.     final Node<K,V>[] helpTransfer(Node<K,V>[] tab, Node<K,V> f) {
  2.         Node<K,V>[] nextTab; int sc;
  3.         if (tab != null && (f instanceof ForwardingNode) &&
  4.             (nextTab = ((ForwardingNode<K,V>)f).nextTable) != null) {
  5.             int rs = resizeStamp(tab.length);
  6.             while (nextTab == nextTable && table == tab &&
  7.                    (sc = sizeCtl) < 0) {
  8.                 if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
  9.                     sc == rs + MAX_RESIZERS || transferIndex <= 0)
  10.                     break;
  11.                 if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)) {
  12.                     transfer(tab, nextTab);
  13.                     break;
  14.                 }
  15.             }
  16.             return nextTab;
  17.         }
  18.         return table;
  19.     }

get 方法

步骤

  1. 根据计算出来的 hashcode 寻址，如果就在桶上那么直接返回值。
  2. 如果是红黑树那就按照树的方式获取值。
  3. 就不满足那就按照链表的方式遍历获取值

源码

  1.     public V get(Object key) {
  2.         Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
  3.         int h = spread(key.hashCode());
  4.         if ((tab = table) != null && (n = tab.length) > 0 &&
  5.             (e = tabAt(tab, (n - 1) & h)) != null) {
  6.             if ((eh = e.hash) == h) {
  7.                 if ((ek = e.key) == key || (ek != null && key.equals(ek)))
  8.                     return e.val;
  9.             }
  10.             else if (eh < 0)
  11.                 return (p = e.find(h, key)) != null ? p.val : null;
  12.             while ((e = e.next) != null) {
  13.                 if (e.hash == h &&
  14.                     ((ek = e.key) == key || (ek != null && key.equals(ek))))
  15.                     return e.val;
  16.             }
  17.         }
  18.         return null;
  19.     }

参考