ConcurrentHashMap源码分析_JDK1.8版本

时间 2019-11-12

标签 concurrenthashmap 源码分析 jdk1.8 jdk 版本栏目 Java 繁體版

原文原文链接

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

改进一：取消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)，能够改进性能。编程

一、jdk1.8的ConcurrentHashMap再也不使用Segment代理Map操做这种设计，总体结构变为HashMap这种结构，可是依旧保留分段锁的思想。以前版本是每一个Segment都持有一把锁，1.8版本改成锁住刚好装在一个hash桶自己位置上的节点，也就是hash桶的第一个节点 tabAt(table, i)，后面直接叫第一个节点。它多是Node链表的头结点、保留节点ReservationNode、或者是TreeBin节点（TreeBin节点持有红黑树的根节点）。还有，1.8的节点变成了4种，这个后面细说，是个重要的知识。

二、能够多线程并发来完成扩容这个耗时耗力的操做。在以前的版本中若是Segment正在进行扩容操做，其余写线程都会被阻塞，jdk1.8改成一个写线程触发了扩容操做，其余写线程进行写入操做时，能够帮助它来完成扩容这个耗时的操做。多线程并发扩容这部分后面细说。

三、由于多线程并发扩容的存在，致使的其余操做的实现上会有比较大的改动，常见的get/put/remove/replace/clear，以及迭代操做，都要考虑并发扩容的影响。

四、使用新的计数方法。不使用Segment时，若是直接使用一个volatile类变量计数，由于每次读写volatile变量的开销很大，高并发时效率不如以前版本的使用Segment时的计数方式。jdk1.8新增了一个用与高并发状况的计数工具类java.util.concurrent.atomic.LongAdder，此类是基本思想和1.7及之前的ConcurrentHashMap同样，使用了一层中间类，叫作Cell（相似Segment这个类）的计数单元，来实现分段计数，最后合并统计一次。由于不一样的计数单元能够承担不一样的线程的计数要求，减小了线程之间的竞争，在1.8的ConcurrentHashMap基本结果改变时，继续保持和分段计数同样的并发计数效率。

关于这个LongAdder，专门写了一篇，能够看下这里。

五、同1.8版本的HashMap，当一个hash桶中的hash冲突节点太多时，把链表变为红黑树，提升冲突时的查找效率。

六、一些小的改进，具体见后面的源码上我写的注释。

七、函数式编程、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的单向队列。api

锁分离实现

当一个线程访问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)，改进性能；app

锁分离

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

待补充；