码迷，mamicode.com
首页 > 其他好文 > 详细

ConcurrentHashMap的JDK1.8实现

时间：2018-05-22 15:08:18      阅读：221      评论：0      收藏：0      [点我收藏+]

标签：不同的   mapping   enc   简化   插入   表结构   查询   pac   情况   

今天我们介绍一下ConcurrentHashMap在JDK1.8中的实现。
基本结构

        ConcurrentHashMap在1.8中的实现，相比于1.7的版本基本上全部都变掉了。首先，取消了Segment分段锁的数据结构，取而代之的是数组+链表（红黑树）的结构。而对于锁的粒度，调整为对每个数组元素加锁（Node）。然后是定位节点的hash算法被简化了，这样带来的弊端是Hash冲突会加剧。因此在链表节点数量大于8时，会将链表转化为红黑树进行存储。这样一来，查询的时间复杂度就会由原先的O(n)变为O(logN)。下面是其基本结构：

技术分享图片

相关属性

[java] view plain copy
  1. private transient volatile int sizeCtl;  

        sizeCtl用于table[]的初始化和扩容操作，不同值的代表状态如下：

  • -1：table[]正在初始化。
  • -N：表示有N-1个线程正在进行扩容操作。

        非负情况：

  1. 如果table[]未初始化，则表示table需要初始化的大小。
  2. 如果初始化完成，则表示table[]扩容的阀值，默认是table[]容量的0.75 倍。
[java] view plain copy
  1. private static finalint DEFAULT_CONCURRENCY_LEVEL = 16;  
  • DEFAULT_CONCURRENCY_LEVEL：表示默认的并发级别，也就是table[]的默认大小。
[java] view plain copy
  1. private static final float LOAD_FACTOR = 0.75f;  
  • LOAD_FACTOR：默认的负载因子。
[java] view plain copy
  1. static final int TREEIFY_THRESHOLD = 8;  
  • TREEIFY_THRESHOLD：链表转红黑树的阀值，当table[i]下面的链表长度大于8时就转化为红黑树结构。
[java] view plain copy
  1. static final int UNTREEIFY_THRESHOLD = 6;  
  • UNTREEIFY_THRESHOLD：红黑树转链表的阀值，当链表长度<=6时转为链表（扩容时）。

构造函数

[java] view plain copy
  1. public ConcurrentHashMap(int initialCapacity,  
  2.                          float loadFactor, int concurrencyLevel) {  
  3.     if (!(loadFactor > 0.0f) || initialCapacity < 0 || concurrencyLevel <= 0)  
  4.         throw new IllegalArgumentException();  
  5.     if (initialCapacity < concurrencyLevel)   // 初始化容量至少要为concurrencyLevel  
  6.         initialCapacity = concurrencyLevel;  
  7.     long size = (long)(1.0 + (long)initialCapacity / loadFactor);  
  8.     int cap = (size >= (long)MAXIMUM_CAPACITY) ?  
  9.         MAXIMUM_CAPACITY : tableSizeFor((int)size);  
  10.     this.sizeCtl = cap;  
  11. }  

        从上面代码可以看出，在创建ConcurrentHashMap时，并没有初始化table[]数组，只对Map容量，并发级别等做了赋值操作。
相关节点

  1. Node：该类用于构造table[]，只读节点（不提供修改方法）。
  2. TreeBin：红黑树结构。
  3. TreeNode：红黑树节点。
  4. ForwardingNode：临时节点（扩容时使用）。

put()操作

[java] view plain copy
  1. public V put(K key, V value) {  
  2.     return putVal(key, value, false);  
  3. }  
  4.   
  5. final V putVal(K key, V value, boolean onlyIfAbsent) {  
  6.     if (key == null || value == null) throw new NullPointerException();  
  7.     int hash = spread(key.hashCode());  
  8.     int binCount = 0;  
  9.     for (Node<K,V>[] tab = table;;) {  
  10.         Node<K,V> f; int n, i, fh;  
  11.         if (tab == null || (n = tab.length) == 0)// 若table[]未创建，则初始化  
  12.             tab = initTable();  
  13.         else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {// table[i]后面无节点时，直接创建Node（无锁操作）  
  14.             if (casTabAt(tab, i, null,  
  15.                          new Node<K,V>(hash, key, value, null)))  
  16.                 break;                   // no lock when adding to empty bin  
  17.         }  
  18.         else if ((fh = f.hash) == MOVED)// 如果当前正在扩容，则帮助扩容并返回最新table[]  
  19.             tab = helpTransfer(tab, f);  
  20.         else {// 在链表或者红黑树中追加节点  
  21.             V oldVal = null;  
  22.             synchronized (f) {// 这里并没有使用ReentrantLock，说明synchronized已经足够优化了  
  23.                 if (tabAt(tab, i) == f) {  
  24.                     if (fh >= 0) {// 如果为链表结构  
  25.                         binCount = 1;  
  26.                         for (Node<K,V> e = f;; ++binCount) {  
  27.                             K ek;  
  28.                             if (e.hash == hash &&  
  29.                                 ((ek = e.key) == key ||  
  30.                                  (ek != null && key.equals(ek)))) {// 找到key，替换value  
  31.                                 oldVal = e.val;  
  32.                                 if (!onlyIfAbsent)  
  33.                                     e.val = value;  
  34.                                 break;  
  35.                             }  
  36.                             Node<K,V> pred = e;  
  37.                             if ((e = e.next) == null) {// 在尾部插入Node  
  38.                                 pred.next = new Node<K,V>(hash, key,  
  39.                                                           value, null);  
  40.                                 break;  
  41.                             }  
  42.                         }  
  43.                     }  
  44.                     else if (f instanceof TreeBin) {// 如果为红黑树  
  45.                         Node<K,V> p;  
  46.                         binCount = 2;  
  47.                         if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,  
  48.                                                        value)) != null) {  
  49.                             oldVal = p.val;  
  50.                             if (!onlyIfAbsent)  
  51.                                 p.val = value;  
  52.                         }  
  53.                     }  
  54.                 }  
  55.             }  
  56.             if (binCount != 0) {  
  57.                 if (binCount >= TREEIFY_THRESHOLD)// 到达阀值，变为红黑树结构  
  58.                     treeifyBin(tab, i);  
  59.                 if (oldVal != null)  
  60.                     return oldVal;  
  61.                 break;  
  62.             }  
  63.         }  
  64.     }  
  65.     addCount(1L, binCount);  
  66.     return null;  
  67. }  

        从上面代码可以看出，put的步骤大致如下：

  1. 参数校验。
  2. 若table[]未创建，则初始化。
  3. 当table[i]后面无节点时，直接创建Node（无锁操作）。
  4. 如果当前正在扩容，则帮助扩容并返回最新table[]。
  5. 然后在链表或者红黑树中追加节点。
  6. 最后还回去判断是否到达阀值，如到达变为红黑树结构。

        除了上述步骤以外，还有一点我们留意到的是，代码中加锁片段用的是synchronized关键字，而不是像1.7中的ReentrantLock。这一点也说明了，synchronized在新版本的JDK中优化的程度和ReentrantLock差不多了。
get()操作

[java] view plain copy
  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());// 定位到table[]中的i  
  4.     if ((tab = table) != null && (n = tab.length) > 0 &&  
  5.         (e = tabAt(tab, (n - 1) & h)) != null) {// 若table[i]存在  
  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. }  

        get()方法的流程相对简单一点，从上面代码可以看出以下步骤：

  1. 首先定位到table[]中的i。
  2. 若table[i]存在，则继续查找。
  3. 首先比较链表头部，如果是则返回。
  4. 然后如果为红黑树，查找树。
  5. 最后再循环链表查找。

        从上面步骤可以看出，ConcurrentHashMap的get操作上面并没有加锁。所以在多线程操作的过程中，并不能完全的保证一致性。这里和1.7当中类似，是弱一致性的体现。
size()操作

[java] view plain copy
  1. // 1.2时加入  
  2. public int size() {  
  3.     long n = sumCount();  
  4.     return ((n < 0L) ? 0 :  
  5.             (n > (long)Integer.MAX_VALUE) ? Integer.MAX_VALUE :  
  6.             (int)n);  
  7. }  
  8. // 1.8加入的API  
  9. public long mappingCount() {  
  10.     long n = sumCount();  
  11.     return (n < 0L) ? 0L : n; // ignore transient negative values  
  12. }  
  13.   
  14. final long sumCount() {  
  15.     CounterCell[] as = counterCells; CounterCell a;  
  16.     long sum = baseCount;  
  17.     if (as != null) {  
  18.         for (int i = 0; i < as.length; ++i) {  
  19.             if ((a = as[i]) != null)  
  20.                 sum += a.value;  
  21.         }  
  22.     }  
  23.     return sum;  
  24. }  

        从上面代码可以看出来，JDK1.8中新增了一个mappingCount()的API。这个API与size()不同的就是返回值是Long类型，这样就不受Integer.MAX_VALUE的大小限制了。
        两个方法都同时调用了，sumCount()方法。对于每个table[i]都有一个CounterCell与之对应，上面方法做了求和之后就返回了。从而可以看出，size()和mappingCount()返回的都是一个估计值。（这一点与JDK1.7里面的实现不同，1.7里面使用了加锁的方式实现。这里面也可以看出JDK1.8牺牲了精度，来换取更高的效率。）

ConcurrentHashMap的JDK1.8实现

标签：不同的   mapping   enc   简化   插入   表结构   查询   pac   情况   

原文地址：https://www.cnblogs.com/tiancai/p/9071512.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！