ConcurrentHashMap源码分析_JDK1.8版本

Posted 温暖的向阳花

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了ConcurrentHashMap源码分析_JDK1.8版本相关的知识,希望对你有一定的参考价值。

在jdk1.8中主要做了2方面的改进

改进一:取消segments字段,直接采用transient volatile HashEntry<K,V>[] table保存数据,采用table数组元素作为锁,从而实现了对每一行数据进行加锁,进一步减少并发冲突的概率。

改进二:将原先table数组+单向链表的数据结构,变更为table数组+单向链表+红黑树的结构。对于hash表来说,最核心的能力在于将key hash之后能均匀的分布在数组中。如果hash之后散列的很均匀,那么table数组中的每个队列长度主要为0或者1。但实际情况并非总是如此理想,虽然ConcurrentHashMap类默认的加载因子为0.75,但是在数据量过大或者运气不佳的情况下,还是会存在一些队列长度过长的情况,如果还是采用单向列表方式,那么查询某个节点的时间复杂度为O(n);因此,对于个数超过8(默认值)的列表,jdk1.8中采用了红黑树的结构,那么查询的时间复杂度可以降低到O(logN),可以改进性能。

1、jdk1.8的ConcurrentHashMap不再使用Segment代理Map操作这种设计,整体结构变为HashMap这种结构,但是依旧保留分段锁的思想。之前版本是每个Segment都持有一把锁,1.8版本改为锁住恰好装在一个hash桶本身位置上的节点,也就是hash桶的第一个节点 tabAt(table, i),后面直接叫第一个节点。它可能是Node链表的头结点、保留节点ReservationNode、或者是TreeBin节点(TreeBin节点持有红黑树的根节点)。还有,1.8的节点变成了4种,这个后面细说,是个重要的知识。
 
2、可以多线程并发来完成扩容这个耗时耗力的操作。在之前的版本中如果Segment正在进行扩容操作,其他写线程都会被阻塞,jdk1.8改为一个写线程触发了扩容操作,其他写线程进行写入操作时,可以帮助它来完成扩容这个耗时的操作。多线程并发扩容这部分后面细说。
 
3、因为多线程并发扩容的存在,导致的其他操作的实现上会有比较大的改动,常见的get/put/remove/replace/clear,以及迭代操作,都要考虑并发扩容的影响。
 
4、使用新的计数方法。不使用Segment时,如果直接使用一个volatile类变量计数,因为每次读写volatile变量的开销很大,高并发时效率不如之前版本的使用Segment时的计数方式。jdk1.8新增了一个用与高并发情况的计数工具类java.util.concurrent.atomic.LongAdder,此类是基本思想和1.7及以前的ConcurrentHashMap一样,使用了一层中间类,叫做Cell(类似Segment这个类)的计数单元,来实现分段计数,最后合并统计一次。因为不同的计数单元可以承担不同的线程的计数要求,减少了线程之间的竞争,在1.8的ConcurrentHashMap基本结果改变时,继续保持和分段计数一样的并发计数效率。
关于这个LongAdder,专门写了一篇,可以看下这里
 
5、同1.8版本的HashMap,当一个hash桶中的hash冲突节点太多时,把链表变为红黑树,提高冲突时的查找效率。
 
6、一些小的改进,具体见后面的源码上我写的注释。
 
7、函数式编程、Stream api相关的新功能,占据了1.8的大概40%的代码,这部分这里就先不说了。
 

JDK1.6版本

ConcurrentHashMap结构

技术分享图片

在JDK1.6中,ConcurrentHashMap将数据分成一段一段存储,给每一段数据配一把锁,当一个线程获得锁互斥访问一个段数据时,其他段的数据也可被其他线程访问;每个Segment拥有一把可重入锁,因此ConcurrentHashMap的分段锁数目即为Segment数组长度。ConcurrentHashMap结构:每一个segment都是一个HashEntry<K,V>[] table, table中的每一个元素本质上都是一个HashEntry的单向队列(单向链表实现)。每一个segment都是一个HashEntry<K,V>[] table, table中的每一个元素本质上都是一个HashEntry的单向队列。

锁分离实现

当一个线程访问Node/键值对数据时,必须获得与它对应的segment锁,其他线程可以访问其他Segment中的数据(锁分离);


ConcurrentHashMap声明

public class ConcurrentHashMap<K,V> extends AbstractMap<K,V> implements ConcurrentMap<K,V>, Serializable


无锁算法:CAS

乐观锁与悲观锁

  • 悲观锁比如synchronized锁,为确保其他线程不会干扰当前线程工作,因此挂起其他需要锁的线程,等待持有锁的线程释放;

  • 乐观锁总是假设没有冲突发生去做操作,如果检测到冲突就失败重试,知道成功为止;

CAS算法

CAS(Compare And Swap):CAS算法包含三个参数CAS(V, E, N),判断预期值E和内存旧值是否相同(Compare),如果相等用新值N覆盖旧值V(Swap),否则失败;
当多个线程尝试使用CAS同时更新同一个变量时,只有其中一个线程能更新变量的值,其他线程失败(失败线程不会被阻塞,而是被告知“失败”,可以继续尝试);
CAS在硬件层面可以被编译为机器指令执行,因此性能高于基于锁占有方式实现线程安全;

ConcurrentHashMap结构图示

技术分享图片

与JDK1.6对比

JDK 1.8取消类segments字段,直接用table数组存储键值对,JDK1.6中每个bucket中键值对组织方式是单向链表,查找复杂度是O(n),JDK1.8中当链表长度超过TREEIFY_THRESHOLD时,链表转换为红黑树,查询复杂度可以降低到O(log n),改进性能;

锁分离

JDK1.8中,一个线程每次对一个桶(链表 or 红黑树)进行加锁,其他线程仍然可以访问其他桶;

线程安全

ConcurrentHashMap底层数据结构与HashMap相同,仍然采用table数组+链表+红黑树结构;
一个线程进行put/remove操作时,对桶(链表 or 红黑树)加上synchronized独占锁;
ConcurrentHashMap采用CAS算法保证线程安全


ConcurrentHashMap基本数据结构

  • transient volatile Node<K,V>[] table:键值对桶数组

  • private transient volatile Node<K,V>[] nextTable: rehash扩容时用到的新键值对数组

  • private transient volatile long baseCount:<span id = "jump1"></span>记录当前键值对总数,通过CAS更新,对所有线程可见

  • private transient volatile int sizeCtl

  • sizeCtl表示键值对总数阈值,通过CAS更新, 对所有线程可见

    • sizeCtl < 0时,表示多个线程在等待扩容;

    • sizeCtl = 0时,默认值;

    • sizeCtl > 0时,表示扩容的阈值;

  • private transient volatile int cellBusy:自旋锁;

  • private transient volatile CounterCell[] counterCells: counter cell表,长度总为2的幂次;

  • static class Segment<K,V>:在JDK1.8中,Segment类仅仅在序列化和反序列化时发挥作用;

// 视图
private transient KeySetView<K,V> keySet
private transient ValuesView<K,V> values
private transient EntrySetView<K,V> entrySet

描述键值对:Node<K, V>

static class Node<K,V> implements Map.Entry<K,V> {
    final int hash;
    final K key;
    // 键值对的value和next均为volatile类型
    volatile V val;
    volatile Node<K,V> next;
    ...
}

ConcurrentHashMap重要方法分析

构造函数

ConcurrentHashMap(int initialCapacity, float loadFactor, int concurrencyLevel)

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

该构造器会根据输入的initialCapacity确定一个 >= initialCapacity的最小2的次幂;

concurrentLevel在JDK1.8之前本质是ConcurrentHashMap分段锁总数,表示同时更新ConcurrentHashMap且不产生锁竞争的最大线程数;在JDK1.8中,仅在构造器中确保初始容量>=concurrentLevel,为兼容旧版本而保留;

添加/更新键值对:putVal

putVal方法分析

final V putVal(K key, V value, boolean onlyIfAbsent) {
    if (key == null || value == null) throw new NullPointerException();
    int hash = spread(key.hashCode());
    int binCount = 0;
    
    // 不断CAS探测,如果其他线程正在修改tab,CAS尝试失败,直到成功为止
    for (Node<K,V>[] tab = table;;) {
        Node<K,V> f; int n, i, fh;
        // 空表,对tab进行初始化
        if (tab == null || (n = tab.length) == 0)
            tab = initTable();
        /**
         * CAS探测空桶
         * 计算key所在bucket表中数组索引: i = (n - 1) & hash)
         */
        else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
            // CAS添加新键值对
            if (casTabAt(tab, i, null,
                         new Node<K,V>(hash, key, value, null)))
                break;                   // no lock when adding to empty bin
        }
        // 检测到tab[i]桶正在进行rehash,
        else if ((fh = f.hash) == MOVED)
            tab = helpTransfer(tab, f);
        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;
            }
        }
    }
    // 更新baseCount
    addCount(1L, binCount);
    return null;
}

synchronized (f) {}操作通过对桶的首元素 = 链表表头 Or 红黑树根节点加锁,从而实现对整个桶进行加锁,有锁分离思想的体现;

获取键值对:get

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

get方法通过CAS保证键值对的原子性,当tab[i]被锁住,CAS失败并不断重试,保证get不会出错;

删除键值对:remove

扩容机制

transfer

baseCount超过sizeCtl,将table中所有bin内的键值对拷贝到nextTable;
待补充;

helpTransfer

待补充;

table原子操作方法

获取tab[i]:tabAt

static final <K,V> Node<K,V> tabAt(Node<K,V>[] tab, int i) {
    return (Node<K,V>)U.getObjectVolatile(tab, ((long)i << ASHIFT) + ABASE);
}

tabAt方法原子读取table[i];调用Unsafe对象的getObjectVolatile方法获取tab[i],由于对volatile写操作happen-before于volatile读操作,因此其他线程对table的修改均对get读取可见;
((long)i << ASHIFT) + ABASE)计算i元素的地址

CAS算法更新键值对:casTabAt

static final <K,V> boolean casTabAt(Node<K,V>[] tab, int i,
                                    Node<K,V> c, Node<K,V> v) {
    return U.compareAndSwapObject(tab, ((long)i << ASHIFT) + ABASE, c, v);
}

casTabAt通过compareAndSwapObject方法比较tabp[i]和v是否相等,相等就用c更新tab[i];

更新键值对:setTabAt

static final <K,V> void setTabAt(Node<K,V>[] tab, int i, Node<K,V> v) {
    U.putObjectVolatile(tab, ((long)i << ASHIFT) + ABASE, v);
}

仅在synchronized同步块中被调用,更新键值对;

CAS更新baseCount

addCountaddCount

private final void addCount(long x, int check) {
    CounterCell[] as; long b, s;
    // s = b + x,完成baseCount++操作;
    if ((as = counterCells) != null ||
        !U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {
        CounterCell a; long v; int m;
        boolean uncontended = true;
        if (as == null || (m = as.length - 1) < 0 ||
            (a = as[ThreadLocalRandom.getProbe() & m]) == null ||
            !(uncontended =
              U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))) {
            // 多线程CAS发生失败时执行
            fullAddCount(x, uncontended);
            return;
        }
        if (check <= 1)
            return;
        s = sumCount();
    }
    if (check >= 0) {
        Node<K,V>[] tab, nt; int n, sc;
        // 当更新后的键值对总数baseCount >= 阈值sizeCtl时,进行rehash
        while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&
               (n = tab.length) < MAXIMUM_CAPACITY) {
            int rs = resizeStamp(n);
            // sc < 0 表示其他线程已经在rehash
            if (sc < 0) {
                if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
                    sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
                    transferIndex <= 0)
                    break;
                // 其他线程的rehash操作已经完成,当前线程可以进行rehash
                if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
                    transfer(tab, nt);
            }
            // sc >= 0 表示只有当前线程在进行rehash操作,调用辅助扩容方法transfer
            else if (U.compareAndSwapInt(this, SIZECTL, sc,
                                         (rs << RESIZE_STAMP_SHIFT) + 2))
                transfer(tab, null);
            s = sumCount();
        }
    }
}

addCount负责对baseCount + 1操作,CounterCell是Striped64类型,否则应对高并发问题;

fullAddCount

待补充;







以上是关于ConcurrentHashMap源码分析_JDK1.8版本的主要内容,如果未能解决你的问题,请参考以下文章

ConcurrentHashMap源码解析_03 put方法源码分析

JDK源码ConcurrentHashMap源码分析

ConcurrentHashMap 源码详细分析(JDK1.8)

源码阅读系列JDK 8 ConcurrentHashMap 源码分析之 由transfer引发的bug

JDK源码分析(12)之 ConcurrentHashMap 详解

ConcurrentHashMap底层实现原理(JDK1.8)源码分析