Java集合系列之五：ConcurrentHashMap底层原理

头像
Half
    阅读 11 分钟

    ConcurrentHashMap底层原理

    ConcurrentHashMap可能会用的相对比较少，因为它跟HashMap其实功能非常相似，但是它是并发安全的，而且1.7和1.8版本中的变化比较大。

    1.7版本

    1. 底层结构

      1.7版本的底层数据结构比较特殊，像是类似于嵌套Map一样，首先整个结构是有一个Segment数组，Segment是一个键值对形式的结构，然后内部存储的是HashEntry数组，这里面才真正的存放数值，而每次加锁的时候会锁住不同操作的那个Segment，也就是说如果操作的不是同一个，那肯定就不会进行加锁操作，默认会有16个Segment。

      static final class Segment<K,V> extends ReentrantLock implements Serializable {
     Segment(float lf, int threshold, HashEntry<K,V>[] tab) {
         this.loadFactor = lf;
         this.threshold = threshold;
         this.table = tab;
     }
     ...
}

static final class HashEntry<K,V> {
   final int hash;
   final K key;
   volatile V value;
   volatile HashEntry<K,V> next;
   ...
}

      concurrenthashmap1.jpg

    2. 构造方法

      总共有好几个构造方法，但是最终都是调用这个构造方法，可以看到就是根据设置的值来创建Segment数组和Segment以及HashEntry数组。

       // 最大分段数量
 static final int MAX_SEGMENTS = 1 << 16;
 // 最大容量
 static final int MAXIMUM_CAPACITY = 1 << 30;
 // 默认分段数量
 static final int DEFAULT_CONCURRENCY_LEVEL = 16;

 @SuppressWarnings("unchecked")
 public ConcurrentHashMap(int initialCapacity, float loadFactor, int concurrencyLevel) {
     if (!(loadFactor > 0) || initialCapacity < 0 || concurrencyLevel <= 0)
         throw new IllegalArgumentException();
     // 限制最大分段数量
     if (concurrencyLevel > MAX_SEGMENTS)
         concurrencyLevel = MAX_SEGMENTS;
     // Find power-of-two sizes best matching arguments
     int sshift = 0;
     // ssize是计算出Segment的容量
     int ssize = 1;
     while (ssize < concurrencyLevel) {
         ++sshift;
         ssize <<= 1;
     }

     // 这两个变量在定位segment时会用到
     this.segmentShift = 32 - sshift;
     this.segmentMask = ssize - 1;

     // 计算segment中每个HashEntry数组的容量
     if (initialCapacity > MAXIMUM_CAPACITY)
         initialCapacity = MAXIMUM_CAPACITY;
     int c = initialCapacity / ssize;
     if (c * ssize < initialCapacity)
         ++c;
     int cap = MIN_SEGMENT_TABLE_CAPACITY;
     while (cap < c)
         cap <<= 1;
     // create segments and segments[0]
     //创建segments数组并初始化第一个Segment，其余的Segment延迟初始化
     Segment<K,V> s0 =
         new Segment<K,V>(loadFactor, (int)(cap * loadFactor),
                          (HashEntry<K,V>[])new HashEntry[cap]);
     Segment<K,V>[] ss = (Segment<K,V>[])new Segment[ssize];
     UNSAFE.putOrderedObject(ss, SBASE, s0); // ordered write of segments[0]
     this.segments = ss;
 }

    3. put()方法

      其实步骤就是先根据初始化定义的两个变量来计算要放到哪个Segment，然后加锁，再定位到Segment里面的HashEntry数组key的插入位置，最后再判断是直接插入还是链表追加，加锁的方式是自旋尝试加锁。

       @SuppressWarnings("unchecked")
 public V put(K key, V value) {
     Segment<K,V> s;
     if (value == null)
         throw new NullPointerException();
     int hash = hash(key);
     // 使用这两个初始化定义的全局变量定位segment，返回的hash值无符号右移segmentShift位与段掩码进行位运算
     int j = (hash >>> segmentShift) & segmentMask;
     if ((s = (Segment<K,V>)UNSAFE.getObject          // nonvolatile; recheck
          (segments, (j << SSHIFT) + SBASE)) == null) //  in ensureSegment
         s = ensureSegment(j);
     // 调用对应的Segment的put()方法
     return s.put(key, hash, value, false);
 }

 final V put(K key, int hash, V value, boolean onlyIfAbsent) {
     // 因为Segment继承ReentrantLock，使用tryLock()尝试获取独占锁
     HashEntry<K,V> node = tryLock() ? null : scanAndLockForPut(key, hash, value);
     // 返回被替换的旧值
     V oldValue;
     // 放入数据
     try {
         // Segment中的HashEntry数组
         HashEntry<K,V>[] tab = table;
         int index = (tab.length - 1) & hash;
         // 找到数组中对应key的第一个元素
         HashEntry<K,V> first = entryAt(tab, index);
         for (HashEntry<K,V> e = first;;) {
             // 第一个元素不为空，直接在后面插入，形成链表
             if (e != null) {
                 K k;
                 if ((k = e.key) == key ||
                     (e.hash == hash && key.equals(k))) {
                     oldValue = e.value;
                     if (!onlyIfAbsent) {
                         e.value = value;
                         ++modCount;
                     }
                     break;
                 }
                 e = e.next;
             }
             // scanAndLockForPut()操作中只有对应位置没有元素才创建node
             // 第一个元素为空，直接把这个node插入
             else {
                 if (node != null)
                     node.setNext(first);
                 else
                     node = new HashEntry<K,V>(hash, key, value, first);
                 int c = count + 1;
                 if (c > threshold && tab.length < MAXIMUM_CAPACITY)
                     rehash(node);
                 else
                     setEntryAt(tab, index, node);
                 ++modCount;
                 count = c;
                 oldValue = null;
                 break;
             }
         }
     } finally {
         // 解锁
         unlock();
     }
     return oldValue;
 }

 private HashEntry<K,V> scanAndLockForPut(K key, int hash, V value) {
     // 获取HashEntry数组上对应key的第一个元素
     HashEntry<K,V> first = entryForHash(this, hash);
     HashEntry<K,V> e = first;
     HashEntry<K,V> node = null;
     int retries = -1; // negative while locating node
     // 自旋获取锁
     while (!tryLock()) {
         HashEntry<K,V> f; // to recheck first below
         if (retries < 0) {
             // 为空就创建一个新节点
             if (e == null) {
                 if (node == null) // speculatively create node
                     node = new HashEntry<K,V>(hash, key, value, null);
                 retries = 0;
             }
             else if (key.equals(e.key))
                 retries = 0;
             else
                 e = e.next;
         }
         // 超过自旋次数，直接锁住
         else if (++retries > MAX_SCAN_RETRIES) {
             lock();
             break;
         }
         // 头节点发生变化，重新遍历
         else if ((retries & 1) == 0 && (f = entryForHash(this, hash)) != first) {
             e = first = f; // re-traverse if entry changed
             retries = -1;
         }
     }
     return node;
 }

    4. get()方法

      get()方法中并没有用锁，而是使用了UNSAFE.getObjectVolatile()来获取，这是一个操作硬件级别的并发类，而这个方法是保证了Volatile语义，也就是取的时候一定会取到最新的值，所以不需要加锁。

       public V get(Object key) {
     Segment<K,V> s; // manually integrate access methods to reduce overhead
     HashEntry<K,V>[] tab;
     int h = hash(key);
     // 计算segment位置
     long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE;
     // 计算HashEntry数组位置中的key位置
     if ((s = (Segment<K,V>)UNSAFE.getObjectVolatile(segments, u)) != null &&
         (tab = s.table) != null) {
         // 循环链表
         for (HashEntry<K,V> e = (HashEntry<K,V>) UNSAFE.getObjectVolatile
                  (tab, ((long)(((tab.length - 1) & h)) << TSHIFT) + TBASE);
              e != null; e = e.next) {
             K k;
             if ((k = e.key) == key || (e.hash == h && key.equals(k)))
                 return e.value;
         }
     }
     return null;
 }

    1.8版本

    1. 底层结构

      在1.8版本的时候数据结构又改回和HashMap类似的数组加链表，链表过长转化为红黑树，也不再使用ReentrantLock来保证并发，而是使用synchronized关键字和CAS操作保证并发问题，因为1.6开始synchronized锁做了优化，比如偏向锁、轻量锁和重量锁的升级，所以性能并不一定就差，但是还是保留了Segment来进行兼容。

      而且可以看到相较于HashMap它的内部节点类里的属性使用volatile来声明。

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

      concurrenthashmap2.jpg

    2. 构造方法

      可以看到除了为了兼容1.7版本而保留的构造方法之外，其他的构造方法都和HashMap差不多。

       public ConcurrentHashMap(int initialCapacity) {
     if (initialCapacity < 0)
         throw new IllegalArgumentException();
     int cap = ((initialCapacity >= (MAXIMUM_CAPACITY >>> 1)) ?
                MAXIMUM_CAPACITY :
                tableSizeFor(initialCapacity + (initialCapacity >>> 1) + 1));
     this.sizeCtl = cap;
 }

 public ConcurrentHashMap(int initialCapacity, float loadFactor) {
     this(initialCapacity, loadFactor, 1);
 }

 public ConcurrentHashMap(int initialCapacity, float loadFactor, int concurrencyLevel) {
     if (!(loadFactor > 0.0f) || initialCapacity < 0 || concurrencyLevel <= 0)
         throw new IllegalArgumentException();
     if (initialCapacity < concurrencyLevel)   // Use at least as many bins
         initialCapacity = concurrencyLevel;   // as estimated threads
     long size = (long)(1.0 + (long)initialCapacity / loadFactor);
     int cap = (size >= (long)MAXIMUM_CAPACITY) ?
         MAXIMUM_CAPACITY : tableSizeFor((int)size);
     this.sizeCtl = cap;
 }

    3. put()方法

      首先是一个循环尝试插入，如果插入的位置上是空的，直接CAS操作插入，如果有值则加synchronized锁，然后修改值，注意的是只锁住了单个索引上的链表或红黑树，也就是说除非是插入操作遇到了哈希碰撞才有加锁操作，否则是不会有加锁操作的，因为不同位置上的值的操作根本不可能有并发问题的，所以不需要加锁。

       public V put(K key, V value) {
     return putVal(key, value, false);
 }

 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;;) {
         Node<K,V> f; int n, i, fh;
         // 数组为空，初始化
         if (tab == null || (n = tab.length) == 0)
             tab = initTable();
         // 当前位置还没有元素，使用Unsafe类的CAS操作放入数据，成功了就跳出循环
         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);
         // 这里会加锁，但是注意锁住了链表或者红黑树，也就是说只单独锁住了数组中这个索引，对于其他的索引位置上的put和get都没有影响
         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;
 }

    4. get()方法

      整个方法就是直接进行哈希计算查找对应位置上的数据，因为前面说了Node节点里的字段都是用volatile修饰，所以取的时候一定会取到最新的值。

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

    总结

    • ConcurrentHashMap对比与HashMap可以解决并发问题，其他的大体原理还是没有太多变化。
    • 1.7版本使用的分段锁，1.8版本则更像是基于HashMap使用synchronized和CAS操作来保证并发问题，而且只锁单个索引位置，性能更好。
    • ConcurrentHashMap是弱一致性的，也就是有些迭代器的方法可能没办法获取最新值，这也是为了性能而舍弃强一致性，不然只能像Hashtable那样直接锁住全部操作了。
    java
    Half
    238 声望17 粉丝

    The Long Way Round.

    « 上一篇
    Java集合系列之四：HashMap底层原理
    下一篇 »
    Java集合系列之六：LinkedHashMap底层原理

    引用和评论

    被 1 篇内容引用
    推荐阅读
    头像
    systemctl命令介绍和使用

    Half赞 1阅读 27.7k

    头像
    Bitmap 和 布隆过滤器傻傻分不清？你这不应该啊

    程序员小富赞 10阅读 4.6k评论 1

    头像
    Jerry和您聊聊Chrome开发者工具

    注销赞 9阅读 4.8k评论 3

    头像
    Spring 实现 3 种异步流式接口，干掉接口超时烦恼

    程序员小富赞 6阅读 2.4k

    头像
    💢线上高延迟请求排查

    crossoverJie赞 6阅读 3.9k评论 5

    头像
    Spring Boot起步，CRUD、错误处理与宝塔部署

    微芒不朽赞 3阅读 3.8k

    头像
    这些年

    注销赞 2阅读 4k

    0 条评论
    得票最新