ConcurrentHashMap在jdk1.7和jdk1.8的实现

最新推荐文章于 2022-11-25 23:24:48 发布

水墨之白

最新推荐文章于 2022-11-25 23:24:48 发布

阅读量413

点赞数

分类专栏：并发编程文章标签： ConcurrentHashMap

本文链接：https://blog.csdn.net/LJJZJ/article/details/89461291

版权

并发编程专栏收录该内容

13 篇文章 0 订阅

订阅专栏

一、ConcurrentHashMap介绍

众所周知，ConcurrentHashMap是用来在多线程的情况下代替HashMap。

HashMap在高并发的情况，写入数据，引起扩容，在扩容的过程中可能形成环形链表，读数据时形成死循环。

ConcurrentHashMap是使用分段锁技术，将集合的读写划分到局部。

二、jdk1.7的实现

jdk1.7中采用Segment + HashEntry的方式进行实现，结构如下

Segment本身就像一个HashMap对象，包含一个HashEntry数组，数组中的每一个HashEntry既是一个键值对，也是一个链表的头节点。每个Segment之间互不影响。

ConcurrentHashMap的读写：

不同Segment可以同时写入，读取
相同的Segment可以同时读写操作，但是不可以同时进行写操作

ConcurrentHashMap 是一个 Segment 数组，Segment 通过继承 ReentrantLock 来进行加锁，所以每次需要加锁的操作锁住的是一个 segment，这样只要保证每个 Segment 是线程安全的，也就实现了全局的线程安全

重要知识点：

Segment 数组长度默认为 16，不可以扩容，所以理论上，这个时候，最多可以同时支持 16 个线程并发写
Segment[i] 的默认大小为 2，负载因子是 0.75，得出初始阈值为 1.5，也就是以后插入第一个元素不会触发扩容，插入第二个会进行第一次扩容

get方法：

对输入的Key做Hash运算，得到hash值。
通过hash值，定位到对应的Segment对象
再次通过hash值，定位到Segment当中数组的具体位置。

在HashMap的基础上再进行一次定位求出具体位置

put方法

为输入的Key做Hash运算，得到hash值。
通过hash值，定位到对应的Segment对象
获取可重入锁
再次通过hash值，定位到Segment当中数组的具体位置。
插入或覆盖HashEntry对象。
释放锁。

size方法

每个 Segment 都有一个 volatile 修饰的全局变量 count ,求size时只需要保证在累加的时候每个Segment没有元素的插入或者删除即可。

过程：

先进行无锁累加，统计modCount 是否改变，如果没有改变则直接返回count的值
若发生改变，则重新计算，重试三次后会对所有Segment进行加锁，再次统计得到size的值

这个过程就是先使用乐观锁求值，当乐观锁无法满足条件的时候，转成悲观锁。

三、jdk 1.8中的实现

1.8中放弃了Segment，而是是采用Node + CAS + Synchronized来保证并发安全进行实现。

链表长度达到8会形成红黑树，所以在调用put方法的时候，需要判断Node位置上是否会形成红黑树，链表采用头插法，即每次是从链表的头位置进行插入，扩容后若树节点个数若<=6，将树转链表。

get方法

get方法是不加锁的

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

put方法

final V putVal(K key, V value, boolean onlyIfAbsent) {
        //key、value均不能为null
        if (key == null || value == null) throw new NullPointerException();
        //计算hash值
        int hash = spread(key.hashCode());
        int binCount = 0;
        for (Node<K,V>[] tab = table;;) {
            Node<K,V> f; int n, i, fh;
            // table为null，进行初始化工作
            if (tab == null || (n = tab.length) == 0)
                tab = initTable();
            //如果i位置没有节点，则直接插入，不需要加锁
            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);
            else {
                V oldVal = null;
                //对该节点进行加锁处理（hash值相同的链表的头节点），对性能有点儿影响
                synchronized (f) {
                    if (tabAt(tab, i) == f) {
                        //fh > 0 表示为链表，将该节点插入到链表尾部
                        if (fh >= 0) {
                            binCount = 1;
                            for (Node<K,V> e = f;; ++binCount) {
                                K ek;
                                //hash 和 key 都一样，替换value
                                if (e.hash == hash &&
                                        ((ek = e.key) == key ||
                                                (ek != null && key.equals(ek)))) {
                                    oldVal = e.val;
                                    //putIfAbsent()
                                    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) {
                    // 如果链表长度已经达到临界值8 就需要把链表转换为树结构
                    if (binCount >= TREEIFY_THRESHOLD)
                        treeifyBin(tab, i);
                    if (oldVal != null)
                        return oldVal;
                    break;
                }
            }
        }

        //size + 1  
        addCount(1L, binCount);
        return null;
    }