0
点赞
收藏
分享

微信扫一扫

java并发编程ConcurrentHashMap(1.7分段锁和1.8CAS)

何以至千里 2022-01-18 阅读 28

东西很多,我就按照其他博客进行分类整理

1.7锁分段技术

https://blog.csdn.net/yansong_8686/article/details/50664351

结构如下,锁分段成数组,每个分段下面存kv
在这里插入图片描述
Segment是可重入锁
在这里插入图片描述
哈希分散后能够更均匀的分配到各个Segment上
在这里插入图片描述
get不加锁,很快,关键在于volatile保证可见性,但不保证原子性
在这里插入图片描述

put对分段Segment加锁,Segment提高效率的地方就在于操作时不需要对整个hashMap都加锁。之后和普通map一样都要考虑扩容
在这里插入图片描述

size将所有Segment的size相加,但考虑如果容器发生变化,则要加锁统计
在这里插入图片描述

1.8并发写机制

https://mp.weixin.qq.com/s/e-ZA9oxzJGRVt0mBjCIi5A

先进去看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) {
        if (key == null || value == null) thrownew 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();
            elseif ((f = tabAt(tab, i = (n - 1) & hash)) == null) { // 如果bucket==null,即没有hash冲突,CAS插入
                if (casTabAt(tab, i, null,
                             new Node<K,V>(hash, key, value, null)))
                    break;                   // no lock when adding to empty bin
            }
            // 如果在进行扩容操作,则先扩容
            elseif ((fh = f.hash) == MOVED)
                tab = helpTransfer(tab, f);
            // 否则,存在hash冲突
            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;
                                // 遍历过程中出现相同key直接覆盖
                                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;
                                }
                            }
                        }
                        // 如果是树节点,遍历红黑树
                        elseif (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);
        returnnull;
    }

put 操作过程如下:

  • 如果没有初始化就先调用 initTable()方法来进行初始化过程
  • 如果没有 hash 冲突就直接 CAS 插入
  • 如果还在进行扩容操作就先进行扩容
  • 如果存在 hash 冲突,就加锁来保证线程安全,这里有两种情况,一种是链表形式就直接遍历到尾端插入,一种是红黑树就按照红黑树结构插入
  • 最后一个如果该链表的数量大于阈值 8,就要先转换成黑红树的结构,break 再一次进入循环
  • 如果添加成功就调用 addCount()方法统计 size,并且检查是否需要扩容

加锁结构如下
在这里插入图片描述
关键是cas的实现:
https://mp.weixin.qq.com/s/7u63bPY_N5-0192akhuXjg
https://www.cnblogs.com/zuoyi2319516228/p/13552216.html

1.7和1.8总结,写的很乱,等前面都了解后再看这个复习:
https://blog.csdn.net/weixin_44460333/article/details/86770169

举报

相关推荐

0 条评论