Java集合(六): ConcurrentHashMap源码剖析
1、ConcurrentHashMap简介
- 和HashMap功能基本一致，主要是为了解决HashMap线程不安全问题；
- java7中的基本设计理念就是切分成多个Segment块，默认是16个，也就是说并发度是16，可以初始化时显式指定，后期不能修改，每个Segment里面可以近似看成一个HashMap，每个Segment块都有自己独立的ReentrantLock锁，所以并发操作时每个Segment互不影响；java8中将Segment块换成了Node，每个Node有自己的锁，即每个Node都有自己的并发度；
- 不允许空值和空键，否则会抛出异常；
2、CHM数据结构
2.1、数据结构
ConcurrentHashMap内部维护了一个Node类型的数组：Node<k,v>[] table，table一共包含 4 种不同类型的桶，5种不同的节点，分别是Node、TreeBin、TreeNode、ForwardingNode和ReservationNode。
数组每一个位置table[i]代表一个桶，当插入键值对时根据键的hash值映射到不同桶位置；
Node节点 是其他四种类型节点的父类；
TreeBin结点 所连接的是一颗红黑树，红黑树的结点用TreeNode表示；
ForwardingNode结点 是临时节点，仅在扩容时才会使用；
ReservationNode结点 是保留节点，只充当占位符加锁使用；
为什么没有直接用TreeNode呢？
主要是因为红黑树的操作比较复杂，包括构建、左旋、右旋、删除，平衡等操作，用一个代理结TreeBin来包含这些复杂操作，其实是一种 “职责分离”的思想，另外TreeBin中也包含了一些加/解锁操作。
在jdk1.8之前，ConcurrentHashMap采用了分段【Segment】锁的设计思路，以减少热点域的冲突，在jdk16中依旧有内部类Segment，目的是为了序列化以及兼容以前的jdk版本；jdk1.8不再延续，转而直接对每个桶加锁，并用“红黑树”链接冲突结点（有兴趣的可以看红黑树的相关讲解）
2.2、CHM类的结点定义
2.2.1、Node结点
- Node是其它四种类型结点的父类；
- 默认链接到table[i]，即桶上的结点就是Node结点；
- 当出现hash冲突时，Node结点会首先以链表的形式链接到table上，当结点数量超过一定数目时，链表会转化为红黑树：因为链表查找的时间复杂度为O(n)，而红黑树是一种平衡二叉树，其平均时间复杂度为O(logn)，这样就提高了效率。
/*
* 普通的Entry结点, 以链表形式保存时才会使用, 存储实际的数据.
*/
static class Node<K,V> implements Map.Entry<K,V> {
final int hash; //通过key计算hash值，通过hash值找相应的桶
final K key;
volatile V val; //volatile修饰，保证可见性、有序性、但和原子性可没什么关系
volatile Node<K,V> next; //volatile修饰,链表指针💛
Node(int hash, K key, V val) { //构造器
this.hash = hash;
this.key = key;
this.val = val;
}
Node(int hash, K key, V val, Node<K,V> next) {
this(hash, key, val);
this.next = next;
}
public final K getKey() { return key; }
public final V getValue() { return val; }
public final int hashCode() { return key.hashCode() ^ val.hashCode(); }
//这里我放的jdk16版本，Helpers我并不太了解，但看其源码就是为JUC包下的一个工具类，帮助toString，如果以后深入了解，再来纠正
public final String toString() { return Helpers.mapEntryToString(key, val); }
public final V setValue(V value) { throw new UnsupportedOperationException(); }
public final boolean equals(Object o) {
Object k, v, u; Map.Entry<?,?> e;
return ((o instanceof Map.Entry) &&
(k = (e = (Map.Entry<?,?>)o).getKey()) != null &&
(v = e.getValue()) != null &&
(k == key || k.equals(key)) &&
(v == (u = val) || v.equals(u)));
}
//链表查找，不同类型的结点有不同的find()方法🧡
Node<K,V> find(int h, Object k) {...}2.2.2、 TreeBin结点
- TreeBin相当于TreeNode的代理结点；
- TreeBin会直接链接到 table[i] 上，该结点提供了一系列红黑树相关的操作，以及加锁、解锁操作：
/*
TreeNode的代理结点（相当于封装了TreeNode的容器，提供针对红黑树的转换操作和锁控制）
hash值固定为-2
*/
static final class TreeBin<K,V> extends Node<K,V> {
TreeNode<K,V> root; // 红黑树结构的根结点
volatile TreeNode<K,V> first; // 链表结构的头结点
volatile Thread waiter; // 最近的一个设置WAITER标识位的线程
volatile int lockState; // 整体的锁状态标识位，0为初始态
// values for lockState
static final int WRITER = 1; // 二进制001，红黑树的写锁状态
static final int WAITER = 2; // 二进制010，红黑树的等待获取写锁状态（优先锁，当有锁等待，读就不能增加了）
// 二进制100，红黑树的读锁状态，读可以并发，每多一个读线程，lockState都加上一个READER值，
static final int READER = 4;
/*
在hashCode相等并且不是Comparable类型时，用此方法判断大小.
*/
static int tieBreakOrder(Object a, Object b) {
int d;
if (a == null || b == null ||
(d = a.getClass().getName().
compareTo(b.getClass().getName())) == 0)
d = (System.identityHashCode(a) <= System.identityHashCode(b) ? -1 : 1);
return d;
}
// 将以b为头结点的链表转换为红黑树
TreeBin(TreeNode<K,V> b) {...}
// 通过lockState,对红黑树的根结点➕写锁.
private final void lockRoot() {
if (!U.compareAndSetInt(this, LOCKSTATE, 0, WRITER))
contendedLock(); // offload to separate method ，Possibly blocks awaiting root lock.
}
//释放写锁
private final void unlockRoot() { lockState = 0; }
// 从根结点开始遍历查找，找到“相等”的结点就返回它，没找到就返回null，当存在写锁时，以链表方式进行查找，后会面会介绍
final Node<K,V> find(int h, Object k) {... }
/**
* 查找指定key对应的结点,如果未找到，则直接插入.
* @return 直接插入成功返回null, 替换返回找到的结点的oldVal
*/
final TreeNode<K,V> putTreeVal(int h, K k, V v) {...}
/*
删除红黑树的结点：
1. 红黑树规模太小时，返回true，然后进行 树 -> 链表 的转化，最后删除;
2. 红黑树规模足够时，不用变换成链表，但删除结点时需要加写锁;
*/
final boolean removeTreeNode(TreeNode<K,V> p) {...}
// 以下是红黑树的经典操作方法，改编自《算法导论》
static <K,V> TreeNode<K,V> rotateLeft(TreeNode<K,V> root , TreeNode<K,V> p) { ...}
static <K,V> TreeNode<K,V> rotateRight(TreeNode<K,V> root , TreeNode<K,V> p) {...}
static <K,V> TreeNode<K,V> balanceInsertion(TreeNode<K,V> root , TreeNode<K,V> x) {...}
static <K,V> TreeNode<K,V> balanceDeletion(TreeNode<K,V> root, TreeNode<K,V> x) { ... }
static <K,V> boolean checkInvariants(TreeNode<K,V> t) {...} //递归检查红黑树的正确性
private static final long LOCKSTATE= U.objectFieldOffset(TreeBin.class, "lockState");
}2.2.3、TreeNode结点
- TreeNode是红黑树的结点，TreeNode不会直接链接到桶上面，而是由TreeBin链接，TreeBin会指红黑树的根结点;
// 红黑树结点，存储实际数据
static final class TreeNode<K,V> extends Node<K,V> {
TreeNode<K,V> parent; // red-black tree links 红黑树链接
TreeNode<K,V> left;
TreeNode<K,V> right;
/* needed to unlink next upon deletion ，prev指针是为了方便删除，
删除链表的非头结点时，需要知道它的前驱结点才能删除，所以直接提供一个prev指针
*/
TreeNode<K,V> prev;
boolean red;
TreeNode(int hash, K key, V val, Node<K,V> next , TreeNode<K,V> parent) {
super(hash, key, val, next);
this.parent = parent;
}
Node<K,V> find(int h, Object k) {
return findTreeNode(h, k, null);
}
//以当前结点（this）为根结点，开始遍历查找指定key.
final TreeNode<K,V> findTreeNode(int h, Object k, Class<?> kc) {...}2.2.4、ForwardingNode结点:
- ForwardingNode结点仅仅在扩容时才会使用
/**
* ForwardingNode是一种临时结点，在扩容进行中才会出现，hash值固定为-1，且不存储实际数据。
* 如果旧table数组的一个桶table[i]中全部的结点都迁移到了新table中，则在这个桶中放置一个ForwardingNode,
即table[i]=ForwardingNode。
* 读操作碰到ForwardingNode时，将操作转到扩容后的新table数组上去执行---》find()方法；写操作碰见它时，则尝试帮助扩容。
*/
static final class ForwardingNode<K, V> extends Node<K, V> {
final Node<K, V>[] nextTable;
ForwardingNode(Node<K,V>[] tab) {
super(MOVED, null, null);
this.nextTable = tab;
}
// 在新的数组(nextTable)上进行查找
Node<K, V> find(int h, Object k) {...}2.2.5、ReservationNode结点
保留节点
/**
* 保留结点.
* hash值固定为-3， 不保存实际数据
* 只在computeIfAbsent和compute这两个函数式API中充当占位符加锁使用
*/
static final class ReservationNode<K, V> extends Node<K, V> {
ReservationNode() {
super(RESERVED, null, null, null);
}
Node<K, V> find(int h, Object k) {
return null;
}
}3、CHM源码分析
3.1、CHM继承结构和层次关系
public class ConcurrentHashMap<K,V> extends AbstractMap<K,V>
implements ConcurrentMap<K,V>, Serializable {
}
CHM继承了AbstractMap，这是一个java.util包下的抽象类，提供Map接口的骨干实现，以最大限度地减少实现Map这类数据结构时所需的工作量，一般来讲，如果需要重复造轮子——自己来实现一个Map，那一般就是继承AbstractMap。
** CHM**实现了ConcurrentMap这个接口，ConcurrentMap是在JDK1.5时随着J.U.C包引入的，这个接口其实就是提供了一些针对Map的原子操作：
public interface ConcurrentMap<K, V> extends Map<K, V> {
}
3.2、类中属性
常量
/**
* 最大容量.
*/
private static final int MAXIMUM_CAPACITY = 1 << 30;
/**
* 默认初始容量
*/
private static final int DEFAULT_CAPACITY = 16;
/**
* The largest possible (non-power of two) array size.
* Needed by toArray and related methods.
*/
static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
/**
* 负载因子，为了兼容JDK1.8以前的版本而保留。
* JDK1.8中的ConcurrentHashMap的负载因子恒定为0.75
*/
private static final float LOAD_FACTOR = 0.75f;
/**
* 链表转树的阈值，即链接结点数大于8时， 链表转换为树.
*/
static final int TREEIFY_THRESHOLD = 8;
/**
* 树转链表的阈值，即树结点树小于6时，树转换为链表.
*/
static final int UNTREEIFY_THRESHOLD = 6;
/**
* 在链表转变成树之前，还会有一次判断：
* 即只有键值对数量大于MIN_TREEIFY_CAPACITY，才会发生转换。
* 这是为了避免在Table建立初期，多个键值对恰好被放入了同一个链表中而导致不必要的转化。
*/
static final int MIN_TREEIFY_CAPACITY = 64;
/**
* 在树转变成链表之前，还会有一次判断：
* 即只有键值对数量小于MIN_TRANSFER_STRIDE，才会发生转换.
*/
private static final int MIN_TRANSFER_STRIDE = 16;
/**
* 用于在扩容时生成唯一的随机数.
*/
private static int RESIZE_STAMP_BITS = 16;
/**
* 可同时进行扩容操作的最大线程数.
*/
private static final int MAX_RESIZERS = (1 << (32 - RESIZE_STAMP_BITS)) - 1;
/**
* The bit shift for recording size stamp in sizeCtl.
*/
private static final int RESIZE_STAMP_SHIFT = 32 - RESIZE_STAMP_BITS;
static final int MOVED = -1; // 标识ForwardingNode结点（在扩容时才会出现，不存储实际数据）
static final int TREEBIN = -2; // 标识红黑树的根结点
static final int RESERVED = -3; // 标识ReservationNode结点（）
static final int HASH_BITS = 0x7fffffff; // usable bits of normal node hash
/**
* CPU核心数，扩容时使用
*/
static final int NCPU = Runtime.getRuntime().availableProcessors();字段
/**
* Node数组，标识整个Map，首次插入元素时创建，大小总是2的幂次.
*/
transient volatile Node<K, V>[] table;
/**
* 扩容后的新Node数组，只有在扩容时才非空.
*/
private transient volatile Node<K, V>[] nextTable;
/**
* 控制table的初始化和扩容.
* 0 : 初始默认值
* -1 : 有线程正在进行table的初始化
* >0 : table初始化时使用的容量，或初始化/扩容完成后的threshold
* -(1 + nThreads) : 记录正在执行扩容任务的线程数
*/
private transient volatile int sizeCtl;
/**
* 扩容时需要用到的一个下标变量.
*/
private transient volatile int transferIndex;
/**
* 计数基值,当没有线程竞争时，计数将加到该变量上。类似于LongAdder的base变量
*/
private transient volatile long baseCount;
/**
* 计数数组，出现并发冲突时使用。类似于LongAdder的cells数组
*/
private transient volatile CounterCell[] counterCells;
/**
* 自旋标识位，用于CounterCell[]扩容时使用。类似于LongAdder的cellsBusy变量
*/
private transient volatile int cellsBusy;
// 视图相关字段
private transient KeySetView<K, V> keySet;
private transient ValuesView<K, V> values;
private transient EntrySetView<K, V> entrySet;3.3、构造方法
CHM提供了五个构造器，这五个构造器内部最多也只是计算了下table的初始容量大小，并没有进行实际的创建table数组的工作：
ConcurrentHashMap，采用了一种 **“懒加载”**的模式，只有到 首次插入键值对的时候，才会真正的去初始化table数组。
3.3.1、空构造器
public ConcurrentHashMap() {
}3.3.2、指定table初始容量的构造器
public ConcurrentHashMap(int initialCapacity) {
if (initialCapacity < 0)
throw new IllegalArgumentException();
int cap = ((initialCapacity >= (MAXIMUM_CAPACITY >>> 1)) ?
MAXIMUM_CAPACITY :
tableSizeFor(initialCapacity + (initialCapacity >>> 1) + 1));
this.sizeCtl = cap;
}3.3.3、指定初始容量和负载因子的构造器
/**
* 指定table初始容量和负载因子的构造器.
*/
public ConcurrentHashMap(int initialCapacity, float loadFactor) {
this(initialCapacity, loadFactor, 1);
}3.3.4、指定初始容量、负载因子和兵法级别的构造器
/**
* 指定table初始容量、负载因子、并发级别的构造器.
* <p>
* 注意：concurrencyLevel只是为了兼容JDK1.8以前的版本，并不是实际的并发级别，loadFactor也不是实际的负载因子
* 这两个都失去了原有的意义，仅仅对初始容量有一定的控制作用
*/
public ConcurrentHashMap(int initialCapacity, float loadFactor, int concurrencyLevel) {
if (!(loadFactor > 0.0f) || initialCapacity < 0 || concurrencyLevel <= 0)
throw new IllegalArgumentException();
if (initialCapacity < concurrencyLevel)
initialCapacity = concurrencyLevel;
long size = (long) (1.0 + (long) initialCapacity / loadFactor);
int cap = (size >= (long) MAXIMUM_CAPACITY) ?
MAXIMUM_CAPACITY : tableSizeFor((int) size);
this.sizeCtl = cap;
}3.3.5、根据已有Map的构造器
/**
* 根据已有的Map构造ConcurrentHashMap.
*/
public ConcurrentHashMap(Map<? extends K, ? extends V> m) {
this.sizeCtl = DEFAULT_CAPACITY;
putAll(m);
}3.4、常用方法
3.4.1、put()源码解析
操作步骤：
- key-value的检验，不允许为空，否则抛出异常；
- 用for(;;) 自旋，无限重试put动作，直到put成功；
- 如果数组没有初始化过则先进行初始化工作；
- 如果数组中该hashcode对应位置不存在元素，则将该元素以CAS方式放入，对应的casTabAt()方法；
- 如果数组中存在元素，用synchronized块保证同步操作
- 循环判断链表中是否存在该value，存在则返回oldValue，不存在则插入链表末端，put成功跳出循环；
- 如果是红黑树，则将元素放入红黑树节点中；
- put完成后根据链表长度是否大于8且数组长度是否大于64来判断是否将链表转换成红黑树；
- 返回oldValue值；
//插入键值对，<K,V>均不能为null.
public V put(K key, V value) {
return putVal(key, value, false);
}3.4.2、putVal()
/**
* 实际的插入操作
* @param onlyIfAbsent true:仅当key不存在时,才插入
*/
final V putVal(K key, V value, boolean onlyIfAbsent) {
if (key == null || value == null) throw new NullPointerException();
int hash = spread(key.hashCode()); // 再次计算hash值,防止并发情况的影响
/*
* binCount 的用法：
* 1、使用链表保存时，binCount记录table[i]这个桶中所保存的结点数；
* 2、使用红黑树保存时，binCount==2，保证put后更改计数值时能够进行扩容检查，同时不触发红黑树化操作
*/
int binCount = 0;
// 自旋插入结点，直到成功
for (Node<K, V>[] tab = table; ; ) {
Node<K, V> f;
int n, i, fh;
// CASE1: 首次初始化table —— 懒加载
if (tab == null || (n = tab.length) == 0)
tab = initTable();
// CASE2: table[i]对应的桶为null，则直接插入结点
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
//tabAt(tab, i)方法是调用Unsafe类的方法查看值，保证每次获取到的值都是最新的
if (casTabAt(tab, i, null, new Node<K, V>(hash, key, value, null))) // cas操作：插入一个链表结点，成功返回
break;
// CASE3: 发现ForwardingNode结点（通过MOVED标识ForwardingNode结点存在），说明此时table正在扩容，则尝试协助数据迁移
} else if ((fh = f.hash) == MOVED)
tab = helpTransfer(tab, f);
// CASE4: 出现hash冲突,也就是table[i]桶中已经有了结点
else {
V oldVal = null;
synchronized (f) { // 对table[i]结点上锁，避免并发情况
if (tabAt(tab, i) == f) { // 再判断一下table[i]是不是第一个结点, 防止其它线程的写修改
//static final int HASH_BITS = 0x7fffffff; // 标识Node结点，自然数
//CASE4.1: （fh >= 0）--->table[i]是链表结点
if (fh >= 0) {
binCount = 1; //记录结点数，超过阈值后，需要转为红黑树，提高查找效率
for (Node<K, V> e = f; ; ++binCount) {
K ek;
// 找到“相等”的结点，判断是否需要更新value值（onlyIfAbsent为false则可以插入）
if (e.hash == hash && ((ek = e.key) == key || (ek != null && key.equals(ek)))) {
oldVal = e.val; //记录key冲突的原来对应的value值
if (!onlyIfAbsent) //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;
}
}
// CASE4.2: 上面判断不是链表结点，则继续判断table[i]是不是红黑树结点
} else if (f instanceof TreeBin) {
Node<K, V> p;
binCount = 2; //红黑树对应的基值，我认为哈是包括了treebin和root，所以以2为基础
if ((p = ((TreeBin<K, V>) f).putTreeVal(hash, key, value)) != null) { //插入
oldVal = p.val;
if (!onlyIfAbsent)
p.val = value;
}
// CASE4.3: 不是链表节点也不是红黑树结点，则看是不是ReservationNode结点用于计算用的（jdk1.8版本没有这个判断）
}else if (f instanceof ReservationNode)
throw new IllegalStateException("Recursive update");
}
}
if (binCount != 0) {
if (binCount >= TREEIFY_THRESHOLD) // 超过阈值，链表 -> 红黑树 转换
treeifyBin(tab, i);
if (oldVal != null) // 表明本次put操作只是替换了旧值，不用更改计数值
return oldVal;
break;
}
}
}
addCount(1L, binCount); //表明本次操作增加了新值， 计数值加1
return null;
}1、spread()求hash值
static final int spread(int h) {
return (h ^ (h >>> 16)) & HASH_BITS;
}2、initTable()
ConcurrentHashMap在构造的时候并不会初始化table数组，首次初始化就在这里通过initTable方法完成，体现了懒加载。
/**
* 初始化table, 使用sizeCtl作为初始化容量.
*/
private final Node<K, V>[] initTable() {
Node<K, V>[] tab;
int sc;
while ((tab = table) == null || tab.length == 0) { //自旋直到初始化成功（每次循环都获取最新的Node数组引用）
if ((sc = sizeCtl) < 0) // sizeCtl<0 ：说明table已经正在初始化/扩容，所以让出CPU时间片
Thread.yield();
else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) { // 将sizeCtl更新成-1,表示正在初始化中
//如果CAS操作成功了，代表本线程将负责初始化工作
try {
//再次检查table数组是否为空
if ((tab = table) == null || tab.length == 0) {
//在初始化Map时，sizeCtl代表数组大小，默认16，所以此时n默认为16
int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
Node<K, V>[] nt = (Node<K, V>[]) new Node<?, ?>[n]; //Node数组nt
table = tab = nt; //将nt其赋值给table,tab变量
sc = n - (n >>> 2); // n - (n >>> 2) = n - n/4 = 0.75n
}
} finally {
//将计算后的sc直接赋值给sizeCtl，表示达到12长度就扩容,由于这里只会有一个线程在执行，直接赋值即可，没有线程安全问题
//只需要保证可见性
sizeCtl = sc;
}
break;
}
}
return tab;
}2.1、如果多个线程同时调用initTable初始化Node数组怎么办？
在初始化数组时使用了乐观锁CAS操作来决定到底是哪个线程有资格进行初始化；volatile变量（sizeCtl）：它是一个标记位，用来告诉其他线程这个坑位有没有人在，其线程间的可见性由volatile保证，CAS操作保证了设置sizeCtl标记位的原子性，保证了只有一个线程能设置成功；
2.2、initTable()： 将sizeCtl字段的值（ConcurrentHashMap对象在构造时设置）作为table的大小；这里的n - (n >>> 2)，其实就是0.75 /* n，sizeCtl 的值最终需要变更为0.75 /* n，相当于设置了阈值threshold；
2.3、table[i]对应的桶为空： 直接CAS操作占用桶table[i]；
2.4、发现ForwardingNode结点，说明此时table正在扩容，则尝试协助进行数据迁移；ForwardingNode结点相当于一个占位结点，表示当前table正在进行扩容，当前线程可以尝试协助数据迁移；
2.5、出现hash冲突，也就是table[i]桶中已经有了结点，当两个不同key映射到同一个 table[i] 桶中时，就会出现这种情况：
- 当table[i]的结点类型为Node——链表结点时，就会将新结点以“尾插法”的形式插入链表的尾部；
- 当table[i]的结点类型为TreeBin——红黑树代理结点时，就会将新结点通过红黑树的插入方式插入；
3.4.3、get()源码解析
- 判断数组是否为空，为空直接返回null；
- 根据hash值查找，如果hash值相等且key也相等，则直接返回value值；
- 如果key的hash值小于0，说明是红黑树，则进入红黑树查找到该节点值；
- 否则进入循环链表读取该value值并返回；
/**
* 根据key查找对应的value值
* @return 查找不到则返回null
* @throws NullPointerException 如果key为空，则抛出异常
*/
public V get(Object key) {
Node<K, V>[] tab;
Node<K, V> e, p;
int n, eh;
K ek;
int h = spread(key.hashCode()); // 重新计算key的hash值
//(e = tabAt(tab, (n - 1) & h)) != null找到对应的桶
if ((tab = table) != null && (n = tab.length) > 0 && (e = tabAt(tab, (n - 1) & h)) != null) {
//CASE1：看table[i]当前节点是不是要找的值
if ((eh = e.hash) == h) { // table[i]就是待查找的桶，直接找值
if ((ek = e.key) == key || (ek != null && key.equals(ek)))
return e.val;
//CASE2：当前节点不是，则判断是不是特殊节点，如果是find查找
} else if (eh < 0) // hash值 < 0 , 说明遇到特殊结点(非链表结点), 调用find方法查找
return (p = e.find(h, key)) != null ? p.val : null;
//CASE3：当前不是特殊节点，则链表遍历查找
while ((e = e.next) != null) { // 遍历table[i]中的结点，因为前面通过eh判断过不是特殊节点了，则直接按链表查找
if (e.hash == h && ((ek = e.key) == key || (ek != null && key.equals(ek))))
return e.val;
}
}
return null;
}用一个类比说：就是先找桶，找到桶，看桶上的结点是不是自己需要的的，如果是就不用打开桶了，直接返回，如果不是我们就看桶里面的结点是不是，而打开桶的方式有两种，一种就是平常的按链表找，另一种就是借助工具 find() 找；
不同的结点有不同的find()实现，这里的find()，是去新数组newtable中查找的
1、链表查找：Node结点的查找
- 当 槽table[i] 被普通Node结点占用，说明是链表链接的形式，直接从链表头开始查找：
/*
* 链表查找.
*/
Node<K, V> find(int h, Object k) {
Node<K, V> e = this;
if (k != null) {
do {
K ek;
if (e.hash == h && ((ek = e.key) == k || (ek != null && k.equals(ek))))
return e;
} while ((e = e.next) != null);
}
return null;
}2、红黑树查找：TreeBin结点的查找
reeBin的查找比较特殊，我们知道当桶table[i]被TreeBin结点占用时，说明链接的是一棵红黑树；
- 由于红黑树的插入、删除等操作会涉及整个结构的调整，所以通常存在读写并发操作的时候，是需要加锁的；
- TreeBin 节点会先拿到对应桶位头节点，然后通过 lockState 判断当前是否有等待者线程或者写线程正在加锁。如果有，则顺序遍历链表，如果没有，则给 TreeBin 节点添加读锁（lockState + 4），调用 findTreeNode 方法查询当前红黑树。最后释放读锁（lockState - 4），此时若有等待者线程就使用 LockSupport.unpark 将等待者线程唤醒。
final Node<K,V> find(int h, Object k) {
if (k != null) {
// e表示循环迭代的当前节点 迭代的是first引用的链表
for (Node<K,V> e = first; e != null; ) {
// s 保存的是lock临时状态
// ek 链表当前节点的key
int s; K ek;
// (WAITER|WRITER) => 0010 | 0001 => 0011
// lockState & 0011 != 0 条件成立：说明当前TreeBin有等待者线程 或者 目前有写操作线程正在加锁
if (((s = lockState) & (WAITER|WRITER)) != 0) {
if (e.hash == h &&
((ek = e.key) == k || (ek != null && k.equals(ek))))
return e;
e = e.next;
}
// 前置条件：当前TreeBin中等待者线程或者写线程都没有
// 条件成立：说明添加读锁成功
else if (U.compareAndSwapInt(this, LOCKSTATE, s,
s + READER)) {
TreeNode<K,V> r, p;
try {
// 查询操作
p = ((r = root) == null ? null :
r.findTreeNode(h, k, null));
} finally {
// w 表示等待者线程
Thread w;
// U.getAndAddInt(this, LOCKSTATE, -READER) == (READER|WAITER)
// 1.当前线程查询红黑树结束，释放当前线程的读锁 就是让 lockstate 值 -4
// (READER|WAITER) = 0110 => 表示当前只有一个线程在读，且“有一个线程在等待”
// 当前读线程为 TreeBin 中的最后一个读线程
// 2.(w = waiter) != null 说明有一个写线程在等待读操作全部结束
if (U.getAndAddInt(this, LOCKSTATE, -READER) ==
(READER|WAITER) && (w = waiter) != null)
// 使用unpark让写线程恢复运行状态
LockSupport.unpark(w);
}
return p;
}
}
}
return null;
}3、ForwardingNode结点的查找
- ForwardingNode是一种临时结点，在扩容进行中才会出现，所以查找也在扩容的table ----》nextTable上进行
/**
* 在新的扩容table—-》nextTable上进行查找
*/
Node<K, V> find(int h, Object k) {
// loop to avoid arbitrarily deep recursion on forwarding nodes
outer:
for (Node<K, V>[] tab = nextTable; ; ) {
Node<K, V> e;
int n;
if (k == null || tab == null || (n = tab.length) == 0 || (e = tabAt(tab, (n - 1) & h)) == null)
return null;
for (; ; ) {
int eh;
K ek;
if ((eh = e.hash) == h && ((ek = e.key) == k || (ek != null && k.equals(ek))))
return e;
if (eh < 0) {
if (e instanceof ForwardingNode) {
tab = ((ForwardingNode<K, V>) e).nextTable;
continue outer;
} else
return e.find(h, k);
}
if ((e = e.next) == null)
return null;
}
}
}4、ReservationNode结点的查找
- ReservationNode是保留结点，不保存实际数据，所以直接返回null：
Node<K, V> find(int h, Object k) { return null; }3.4.4、CHM类的扩容原理
扩容两个步骤：
- 1、table数组的扩容：table数组的扩容，一般就是新建一个2倍大小的槽数组，这个过程通过由一个单线程完成，且不允许出现并发；
- 2、数据迁移：就是把旧table中的各个槽中的结点重新分配到新table中；比如，单线程情况下，可以遍历原来的table，然后put()到新table中；这一过程通常涉及到槽中key的rehash()，因为 key映射到桶的位置与table的大小有关，新table的大小变了，key映射的位置一般也会变化，所以我们需要重新计算hash值；
ConcurrentHashMap在处理 rehash() 的时候，并不会重新计算每个key的hash值，而是利用了一种很巧妙的方法。
ConcurrentHashMap内部的table数组的大小必须为2的幂次，这是为什么呢？
- 1、让key均匀分布，减少冲突；
- 2、当table数组的大小为2的幂次时，通过key.hash & table.length-1这种方式计算出的索引i，当table扩容后（2倍），新的索引要么在原来的位置i，要么是i+n。如果索引变为i+n,那么其变化后的索引最高位一定是1（因为table.length-1的最高位一定是1）。
我们通过一个例子说明：
- 扩容前，table数组大小为16，key1和key2映射到同一个索引5；
- 扩容后，table数组的大小变成 2/*16=32 ，key1的索引不变，key2的索引变成 5+16=21。
ConcurrentHashMap 在扩容时，这样处理能带来什么好处呢？
这种处理方式非常利于扩容时多个线程同时进行的数据迁移操作，因为旧table的各个桶中的结点迁移不会互相影响，所以就可以用 “分治” 的方式，将整个table数组划分为很多部分，每一部分包含一定区间的桶，每个数据迁移线程处理各自区间中的结点，对多线程同时进行数据迁移非常有利。
3.4.5、CHM的扩容时机
当往table[i]中插入结点时，如果链表的结点数目超过一定阈值（8），就会触发链表 -> 红黑树的转换，这样提高了 查找效率：
if (binCount >= TREEIFY_THRESHOLD)
treeifyBin(tab, i); // 链表 -> 红黑树 转换接下来我们分析这个 链表 -> 红黑树 的转换操作，treeifyBin(tab, i)：
/*
* 链表 -> 红黑树 转换
*/
private final void treeifyBin(Node<K,V>[] tab, int index) {
Node<K,V> b; int n;
if (tab != null) {
// CASE 1: table的容量 < MIN_TREEIFY_CAPACITY时，直接进行table扩容，不进行红黑树转换，MIN_TREEIFY_CAPACITY默认为64
if ((n = tab.length) < MIN_TREEIFY_CAPACITY)
tryPresize(n << 1);
// CASE 2: table的容量 ≥ MIN_TREEIFY_CAPACITY时，进行相应桶的链表 -> 红黑树的转换
else if ((b = tabAt(tab, index)) != null && b.hash >= 0) {
synchronized (b) { //同步,对相应的桶的对象加锁
if (tabAt(tab, index) == b) {
TreeNode<K,V> hd = null, tl = null;
//遍历链表，建立红黑树
for (Node<K,V> e = b; e != null; e = e.next) {
TreeNode<K,V> p = new TreeNode<K,V>(e.hash, e.key, e.val, null, null);//结点类型转换
if ((p.prev = tl) == null)
hd = p;
else
tl.next = p;
tl = p;
}
// 以TreeBin类型包装，并链接到table[index]中
setTabAt(tab, index, new TreeBin<K,V>(hd));
}
}
}
}
}通过 treeifyBin(Node<K,V>[] tab, int index) 源码可以看出，链表 -> 红黑树这一转换并不是一定会进行的：
- 当桶的容量 < MIN_TREEIFY_CAPACITY(64)，CurrentHashMap 会首先选择扩容（调用 tryPresize() 把数组长度扩大到原来的两倍），而非立即转成红黑树；
- 当桶的容量 >= MIN_TREEIFY_CAPACITY(64)，则选择 链表 -> 红黑树；
参考：大厂之路一由浅入深、并行基础、源码分析一 “J.U.C”之collections框架：ConcurrentHashMap扩容迁移等方法的源码分析（学妹哭着对我说：太难了！！！！我要回家！！）_菜菜子-CSDN博客
版权说明 : 本文为转载文章, 版权归原作者所有 版权申明
原文链接 : https://blog.csdn.net/mingyuli/article/details/120462735
内容来源于网络，如有侵权，请联系作者删除！
相关文章
热门标签
更多最新文章
更多- 浏览(620) 发布于 4个月前
- 浏览(211) 发布于 4个月前
- 浏览(195) 发布于 4个月前
- 浏览(198) 发布于 4个月前
- 浏览(199) 发布于 4个月前