本文共 3763 字，大约阅读时间需要 12 分钟。

一 ConcurrentHashMap 1.8

Java8 Node 数组 + 链表 / 红黑树。当冲突链表达到一定长度时，链表会转换成红黑树。 2. 初始化 initTable

/**

• Initializes table, using the size recorded in sizeCtl.
  */
  private final Node<K,V>[] initTable() {
  Node<K,V>[] tab; int sc;
  while ((tab = table) == null || tab.length == 0) {
  ／／ 如果 sizeCtl < 0 ,说明另外的线程执行CAS 成功，正在进行初始化。
  if ((sc = sizeCtl) < 0)
  // 让出 CPU 使用权
  Thread.yield(); // lost initialization race; just spin
  else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
  try {
  if ((tab = table) == null || tab.length == 0) {
  int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
  @SuppressWarnings(“unchecked”)
  Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
  table = tab = nt;
  sc = n - (n >>> 2);
  }
  } finally {
  sizeCtl = sc;
  }
  break;
  }
  }
  return tab;
  }
  从源码中可以发现 ConcurrentHashMap 的初始化是通过自旋和 CAS 操作完成的。里面需要注意的是变量 sizeCtl ，它的值决定着当前的初始化状态。
  -1 说明正在初始化
  -N 说明有N-1个线程正在进行扩容
  表示 table 初始化大小，如果 table 没有初始化
  表示 table 容量，如果 table　已经初始化。

3. put

直接过一遍 put 源码。

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) { // key 和 value 不能为空 if (key == null || value == null) throw new NullPointerException(); int hash = spread(key.hashCode()); int binCount = 0; for (Node<K,V>[] tab = table;😉 { // f = 目标位置元素 Node<K,V> f; int n, i, fh;// fh 后面存放目标位置的元素 hash 值 if (tab == null || (n = tab.length) == 0) // 数组桶为空，初始化数组桶（自旋+CAS) tab = initTable(); else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) { // 桶内为空，CAS 放入，不加锁，成功了就直接 break 跳出 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 加锁加入节点 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; } 根据 key 计算出 hashcode 。 判断是否需要进行初始化。 即为当前 key 定位出的 Node，如果为空表示当前位置可以写入数据，利用 CAS 尝试写入，失败则自旋保证成功。 如果当前位置的 hashcode == MOVED == -1,则需要进行扩容。 如果都不满足，则利用 synchronized 锁写入数据。 如果数量大于 TREEIFY_THRESHOLD 则要转换为红黑树。 4. get

get 流程比较简单，直接过一遍源码。

public V get(Object key) { Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek; // key 所在的 hash 位置 int h = spread(key.hashCode()); if ((tab = table) != null && (n = tab.length) > 0 && (e = tabAt(tab, (n - 1) & h)) != null) { // 如果指定位置元素存在，头结点hash值相同 if ((eh = e.hash) == h) { if ((ek = e.key) == key || (ek != null && key.equals(ek))) // key hash 值相等，key值相同，直接返回元素 value return e.val; } else if (eh < 0) // 头结点hash值小于0，说明正在扩容或者是红黑树，find查找 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; } 总结一下 get 过程： 根据 hash 值计算位置。 查找到指定位置，如果头节点就是要找的，直接返回它的 value. 如果头节点 hash 值小于 0 ，说明正在扩容或者是红黑树，查找之。 如果是链表，遍历查找之。 总结： 总的来说 ConcruuentHashMap 在 Java8 中相对于 Java7 来说变化还是挺大的， 3. 总结

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

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

转载地址：http://balwi.baihongyu.com/