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)，改进性能；
Segment类在JDK1.8中与之前的版本的JDK作用存在很大的差别，JDK1.8下，其在普通的ConcurrentHashMap操作中已经失效，它主要是为了兼容以前的JDK版本，在序列化与反序列化的时候发挥作用。
锁分离
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：记录当前键值对总数，通过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，为兼容旧版本而保留；
初始化方法：initTable
对于ConcurrentHashMap来说，调用它的构造方法仅仅是设置了一些参数而已。而整个table的初始化是在向ConcurrentHashMap中插入元素的时候发生的。如调用put、computeIfAbsent、compute、merge等方法的时候，调用时机是检查table==null。
初始化方法主要应用了关键属性sizeCtl 如果这个值〈0，表示其他线程正在进行初始化，就放弃这个操作。在这也可以看出**ConcurrentHashMap的初始化只能由一个线程完成。如果获得了初始化权限，就用CAS方法将sizeCtl置为-1，防止其他线程进入。**初始化数组后，将sizeCtl的值改为0.75*n
/**
* Initializes table, using the size recorded in sizeCtl.
*/
private final Node<K,V>[] initTable() {
Node<K,V>[] tab; int sc;
while ((tab = table) == null || tab.length == 0) {
//sizeCtl表示有其他线程正在进行初始化操作，把线程挂起。对于table的初始化工作，只能有一个线程在进行。
if ((sc = sizeCtl) < 0)
Thread.yield(); // lost initialization race; just spin
else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {//利用CAS方法把sizectl的值置为-1 表示本线程正在进行初始化
try {
if ((tab = table) == null || tab.length == 0) {
int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
@SuppressWarnings("unchecked")
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
table = tab = nt;
sc = n - (n >>> 2);//相当于0.75*n 设置一个扩容的阈值
}
} finally {
sizeCtl = sc;
}
break;
}
}
return tab;
}
添加/更新键值对：putVal
putVal方法分析
final V putVal(K key, V value, boolean onlyIfAbsent) { //不允许key或value为null值 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;
//如果hash值和key值相同 则修改对应结点的value值
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;
}
}
}
}
// 检查桶中键值对总数，如果链表长度已经达到临界值8 就需要把链表转换为树结构
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;
//计算hash值
int h = spread(key.hashCode());
//根据hash值确定节点位置
if ((tab = table) != null && (n = tab.length) > 0 &&
(e = tabAt(tab, (n - 1) & h)) != null) {
//如果搜索到的节点key与传入的key相同且不为null,直接返回这个节点
if ((eh = e.hash) == h) {
if ((ek = e.key) == key || (ek != null && key.equals(ek)))
return e.val;
}
//如果eh<0 说明这个节点在树上 直接寻找
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方法比较简单，给定一个key来确定value的时候，必须满足两个条件——key相同、hash值相同，对于节点可能在链表或树上的情况，需要分别去查找.
删除键值对：remove
remove函数底层是调用的replaceNode函数实现结点的删除：
final V replaceNode(Object key, V value, Object cv) {
// 计算key的hash值
int hash = spread(key.hashCode());
for (Node<K,V>[] tab = table;;) { // 无限循环
Node<K,V> f; int n, i, fh;
if (tab == null || (n = tab.length) == 0 ||
(f = tabAt(tab, i = (n - 1) & hash)) == null) // table表为空或者表长度为0或者key所对应的桶为空
// 跳出循环
break;
else if ((fh = f.hash) == MOVED) // 桶中第一个结点的hash值为MOVED
// 转移
tab = helpTransfer(tab, f);
else {
V oldVal = null;
boolean validated = false;
synchronized (f) { // 加锁同步
if (tabAt(tab, i) == f) { // 桶中的第一个结点没有发生变化
if (fh >= 0) { // 结点hash值大于0
validated = true;
for (Node<K,V> e = f, pred = null;;) { // 无限循环
K ek;
if (e.hash == hash &&
((ek = e.key) == key ||
(ek != null && key.equals(ek)))) { // 结点的hash值与指定的hash值相等，并且key也相等
V ev = e.val;
if (cv == null || cv == ev ||
(ev != null && cv.equals(ev))) { // cv为空或者与结点value相等或者不为空并且相等
// 保存该结点的val值
oldVal = ev;
if (value != null) // value为null
// 设置结点value值
e.val = value;
else if (pred != null) // 前驱不为空
// 前驱的后继为e的后继，即删除了e结点
pred.next = e.next;
else
// 设置table表中下标为index的值为e.next
setTabAt(tab, i, e.next);
}
break;
}
pred = e;
if ((e = e.next) == null)
break;
}
}
else if (f instanceof TreeBin) { // 为红黑树结点类型
validated = true;
// 类型转化
TreeBin<K,V> t = (TreeBin<K,V>)f;
TreeNode<K,V> r, p;
if ((r = t.root) != null &&
(p = r.findTreeNode(hash, key, null)) != null) { // 根节点不为空并且存在与指定hash和key相等的结点
// 保存p结点的value
V pv = p.val;
if (cv == null || cv == pv ||
(pv != null && cv.equals(pv))) { // cv为空或者与结点value相等或者不为空并且相等
oldVal = pv;
if (value != null)
p.val = value;
else if (t.removeTreeNode(p)) // 移除p结点
setTabAt(tab, i, untreeify(t.first));
}
}
}
}
}
if (validated) {
if (oldVal != null) {
if (value == null)
// baseCount值减一
addCount(-1L, -1);
return oldVal;
}
break;
}
}
}
return null;
}
扩容机制
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读取可见；
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
addCount
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操作。
参考链接
- ConcurrentHashMap源码分析_JDK1.8版本
- ConcurrentHashMap源码分析（JDK8版本）
- 【JUC】JDK1.8源码分析之ConcurrentHashMap（一）
- 探索jdk8之ConcurrentHashMap 的实现机制
- Java进阶（六）从ConcurrentHashMap的演进看Java多线程核心技术
zhuan :https://my.oschina.net/dabird/blog/1570301