目录
数据结构
和jdk1.8的HashMap一样,使用的是数组+链表+红黑树的结构
1、HashMap详解
源码分析
重要常量
/**
* 默认最大容量
*/
private static final int MAXIMUM_CAPACITY = 1 << 30;
/**
* 默认初始化数组容量=16 . 即默认有16个bucket
*/
private static final int DEFAULT_CAPACITY = 16;
/**
* 最大数组长度 Integer的最大值 - 8 的长度
*/
static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
/**
* 默认的并发级别:16 . 即最多允许16个线程并发 ..
* jdk1.7中采用的是分段锁并发访问处理 . 此方式有很大的局限性
* jdk1.8中放弃了锁分段的做法 , 采用了CAS+synchronized方式处理并发 .
*/
private static final int DEFAULT_CONCURRENCY_LEVEL = 16;
/**
* 扩容时的触发条件 . 即负载因子. 当达到当前容量 * 0.75时 , 进行扩容
*/
private static final float LOAD_FACTOR = 0.75f;
/**
* 树形化阈值.当链表长度达到8时 , 转换为树形结构
*/
static final int TREEIFY_THRESHOLD = 8;
/**
* 当树结构中的节点数量达到6时 , 红黑树结构转换为链表结构
*/
static final int UNTREEIFY_THRESHOLD = 6;
/**
* 最小树形化需要的数组长度 . 达不到该值时 , 只进行扩容操作
*/
static final int MIN_TREEIFY_CAPACITY = 64;
/**
* table进行扩容时 , 每个线程最小迁移的table的槽位数 .
* 扩容时 , 在最大容量范围内 , 容量都是以2倍的方式进行 . 初始时容量16 , 则最小迁移槽位是16
*/
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;
/**
* 扩容阈值计算时的偏移量-default = 16
*/
private static final int RESIZE_STAMP_SHIFT = 32 - RESIZE_STAMP_BITS;
内部静态方法
/**
* 位运算 . 通过移位降低Hash碰撞的风险
*
* @param h
* @return
*/
private static final int spread(int h) {
return (h ^ (h >>> 16)) & HASH_BITS;
}
/**
* 通过位运算将传入的数据换算为2的N次方的数值
*/
private static final int tableSizeFor(int c) {
int n = c - 1;
n |= n >>> 1;
n |= n >>> 2;
n |= n >>> 4;
n |= n >>> 8;
n |= n >>> 16;
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}
/**
* 判断对象是否实现compare接口 ,
* 若实现 : 返回对象类型 .
* 否则 : 返回null
* @param x
* @return
*/
static Class<?> comparableClassFor(Object x) {
if (x instanceof Comparable) {
Class<?> c;
Type[] ts, as;
Type t;
ParameterizedType p;
if ((c = x.getClass()) == String.class)
//若为字符串 . 返回string
return c;
if ((ts = c.getGenericInterfaces()) != null) {
//循环类x实现的所有接口
for (int i = 0; i < ts.length; ++i) {
if (((t = ts[i]) instanceof ParameterizedType) &&
((p = (ParameterizedType) t).getRawType() ==
Comparable.class) &&
(as = p.getActualTypeArguments()) != null &&
as.length == 1 && as[0] == c) // type arg is c
return c;
}
}
}
return null;
}
/**
* 如果x与kc(k)类型匹配 ,则返回 k.compareTo(x)对比值,若x为空或者类型不匹配 . 直接返回0
*/
@SuppressWarnings({"rawtypes", "unchecked"}) // for cast to Comparable
static int compareComparables(Class<?> kc, Object k, Object x) {
return (x == null || x.getClass() != kc ? 0 :
((Comparable) k).compareTo(x));
}
/* ---------------- Table element access -------------- */
/**
* 寻找指定数组在内存中i位置的内容
* getObjectVolatile(): 获取obj对象中offset偏移地址对应的tab的field值,支持volatile load语义
* ABASE : 起始位置
*
* @param tab 指定的数组
* @param i 位置
* @param <K>
* @param <V>
* @return
*/
@SuppressWarnings("unchecked")
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);
}
/**
* 比较并替换
*
* @param tab 包含要替换对象的数组
* @param i 字段在对象内的下标,用于计算对象地址偏移量
* @param c 期望的值
* @param v 若当前值等于期望的值,进行替换 .用于进行更新替换的值
* @param <K>
* @param <V>
* @return
*/
static final <K, V> boolean casTabAt(Node<K, V>[] tab, int i,
Node<K, V> c, Node<K, V> v) {
//native 方法 . 采用C++实现
// 通过我们传入的字段在对象中的偏移量,来获取到字段的地址(包括首地址+偏移量)
// 通过对比两个字段的地址是否相同.若相同,则使用v的地址进行替换
return U.compareAndSwapObject(tab, ((long) i << ASHIFT) + ABASE, c, v);
}
/**
* 设置数组中某个下标处的值
*
* @param tab 数组对象
* @param i 字段在对象内的下标,用于计算对象地址偏移量
* @param v 要设置的值
* @param <K>
* @param <V>
*/
static final <K, V> void setTabAt(Node<K, V>[] tab, int i, Node<K, V> v) {
U.putObjectVolatile(tab, ((long) i << ASHIFT) + ABASE, v);
}
重要成员变量
/**
* 在第一次插入数据时才会延迟初始化
* 大小总是二的幂次方。由迭代器直接访问。
* 为线程共享变量
*/
transient volatile Node<K, V>[] table;
/**
* 下一个要使用的数组,只有在扩容时才不为空
* 线程共享变量
*/
private transient volatile Node<K, V>[] nextTable;
/**
* 基本计数器,主要在没有争用时使用,但在数组初始化竞争期间用作比对回退参考值.更新通过CAS-共享变量
*/
private transient volatile long baseCount;
/**
* 表初始化和调整控件大小。如果为负值,则表正在初始化或调整大小:-1用于初始化,若为>= 1 : 活动调整大小线程的数量
* 否则,当table为null时,将保留创建时使用的初始表大小,默认值为0。初始化后,保存下一个要调整表大小的元素计数值。-共享变量
*/
private transient volatile int sizeCtl;
/**
* 扩容时要分割的下一个表的索引-共享变量
*/
private transient volatile int transferIndex;
/**
* Spinlock (locked via CAS) used when resizing and/or creating CounterCells.
* 扩容或者创建计数器单元格时使用的自旋锁(通过CAS锁定)-共享变量,用来标记当前数组是否在初始化或者扩容
*/
private transient volatile int cellsBusy;
/**
* 计数器数组。
* 非空时,大小为2的幂次方。
* 并发情况下,采用分段并发,每个值记录每个段的数据的长度.
* 计算总量时,将数组的值累加求和即为当前集合的总节点数
*/
private transient volatile CounterCell[] counterCells;
构造函数
/**
* Creates a new, empty map with the default initial table size (16).
* 构造器,创建一个空的map对象 , 默认带长度[16]的数组
*/
public ConcurrentHashMap() {
}
/**
* 构造器, 创建一个新的空map,可指定其初始化的数组的大小 . 而不需动态调增
*/
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;
}
/**
* 根据入参的map集合类型,创建一个相同的map集合 , 并初始化数据
*
* @param m the map
*/
public ConcurrentHashMap(Map<? extends K, ? extends V> m) {
this.sizeCtl = DEFAULT_CAPACITY;
putAll(m);
}
/**
* 构造器
* @param initialCapacity 初始化容量
* @param loadFactor 加载因子
*/
public ConcurrentHashMap(int initialCapacity, float loadFactor) {
this(initialCapacity, loadFactor, 1);
}
/**
* 构造器
* @param initialCapacity 初始化容量
* @param loadFactor 加载因子
* @param concurrencyLevel 并发级别--default = 16
*/
public ConcurrentHashMap(int initialCapacity,
float loadFactor, int concurrencyLevel) {
if (!(loadFactor > 0.0f) || initialCapacity < 0 || concurrencyLevel <= 0)
throw new IllegalArgumentException();
if (initialCapacity < concurrencyLevel) // 尽可能少的使用concurrencyLevel
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;
}
确保当前table的大小为2的N次方
/**
* 通过位运算将传入的数据换算为>=c的2的N次方的数值
* 如 :
* 入参: 8 .return 8
* 入参: 10 .return 16
* 入参: 17 .return 32
*/
private static final int tableSizeFor(int c) {
int n = c - 1;
n |= n >>> 1;
n |= n >>> 2;
n |= n >>> 4;
n |= n >>> 8;
n |= n >>> 16;
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}
put操作
/**
* put and putIfAbsent
*/
final V putVal(K key, V value, boolean onlyIfAbsent) {
//key & value 不为null
if (key == null || value == null) throw new NullPointerException();
//计算偏移量-类似于计算hashcode.[将结果值控制在Integer.max范围内]
int hash = spread(key.hashCode());
int binCount = 0;
//死循环处理,直到插入成功
for (Node<K, V>[] tab = table; ; ) {
Node<K, V> f;
int n, i, fh;
//若当前数组table为空 . 则进行初始化
if (tab == null || (n = tab.length) == 0)
//初始化node数组
tab = initTable();
//根据key的hash值计算key在table中的下标i,取出该节点赋值给f
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
//i = (n - 1) & hash 等同于 i=hash%n(前提是n等于2的幂次方)
//如果table[i]==null(没有发生碰撞 即该位置的节点为空),
//直接利用CAS操作将该value存储在该位置,若CAS成功,直接退出死循环
if (casTabAt(tab, i, null,
new Node<K, V>(hash, key, value, null)))
break; // 当添加到空的bin时不上锁
}
//若节点位置不为空 , 说明map中该位置已存在节点
//若table[i]节点的hash值为-1 , 说明当前map正在扩容 , 这时当前线程会帮助执行扩容以加快速度并返回扩容后的新的数组
else if ((fh = f.hash) == MOVED)
//帮助扩容
tab = helpTransfer(tab, f);
else {
//table[i]的节点的hash值不等于MOVED[-1] ,说明当前不是处于扩容状态
V oldVal = null;
//锁住节点f[在上面的处理中说明逻辑执行到这里时节点f不为null],在加锁期间不允许其他线程操作
//synchronized (f)也实现了线程安全,确保该节点不会被其他线程操作处理 .
// 但也只是锁住该节点.该数组下其他的数据不受影响,也支持并发处理
synchronized (f) {
if (tabAt(tab, i) == f) {
//表示链表节点
if (fh >= 0) {
//循环插入到链表中
binCount = 1;
for (Node<K, V> e = f; ; ++binCount) {
K ek;
//查询链表中是否出现了同样的key,若出现则直接更新value,并跳出循环
if (e.hash == hash &&
((ek = e.key) == key ||
(ek != null && key.equals(ek)))) {
oldVal = e.val;
if (!onlyIfAbsent)
e.val = value;
break;
}
//若查询链表没有同样的key , 则直接将数据插入到链表尾部 , 并跳出循环
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 MyConcurrentHashMap.TreeBin) {
//如果table[i]为树节点,将节点node转成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) {
//链表结构中新增节点时,变量binCount才会依次新增,红黑树结构中添加节点时,binCount = 2;
//binCount >= TREEIFY_THRESHOLD[8]: 判断是否达到树形化阈值条件 . 将链表结构转变为红黑树
//binCount = 2;表示当前已经是树形化结构了
if (binCount >= TREEIFY_THRESHOLD)
{
treeifyBin(tab, i);
}
if (oldVal != null)
//若当前节点的旧value不为空,插入成功后返回oldVal
{
return oldVal;
}
break;
}
}
}
//节点计数器+1
addCount(1L, binCount);
return null;
}
初始化数组
在高并发的场景下,initTable()方法通过cas(compareAndSwapInt)的机制来保证只有一个线程能够成功初始化。其他线程放弃本次循环的cpu竞争,进行自旋。但是这样有可能导致cpu占有率过高的问题?比如:一个线程本次循环放弃竞争,但是第二次循环又竞争到了cpu,依次叠加,就会导致cpu占有率过高甚至百分之百的问题
/**
* 使用sizeCtl中记录的值初始化数组
*/
private final Node<K, V>[] initTable() {
Node<K, V>[] tab;
int sc;
// 执行条件 , 当前数组table为空或者长度为0
while ((tab = table) == null || tab.length == 0) {
//若sizeCtl[偏移量-用于计算字段在数组中的地址]小于0.执行Thread.yield():使当前线程由执行状态,变成为就绪状态,让出cpu时间,
// 在下一个线程执行时候,此线程有可能被执行,也有可能没有被执行。
if ((sc = sizeCtl) < 0)
Thread.yield();
//将偏移量设置为-1,表明当前正在执行初始化 . 后续线程将被挂起进入就绪状态.
else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
//初始化数组长度,并替换当前sizeCtl的值用于后续扩容
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);
}
} finally {
sizeCtl = sc;
}
break;
}
}
return tab;
}
辅助扩容
/**
* 帮助执行扩容
* 关于 sizeCtl 变量:
* -1 :代表table正在初始化,其他线程应该交出CPU时间片; -N: 表示正有N-1个线程执行扩容操作(高 16 位是 length 生成的标识符,低 16 位是扩容的线程数)
* 大于 0: 如果table已经初始化,代表table容量,默认为table大小的0.75,如果还未初始化,代表需要初始化的大小
*
* @param tab 当前table数组
* @param f 当前槽位的变量
* @return
*/
final Node<K, V>[] helpTransfer(Node<K, V>[] tab, Node<K, V> f) {
Node<K, V>[] nextTab;
int sc;
//数据校验 : table数组不为空 , 且node节点为转移类型 , 且node节点的nextTable不为空. 尝试帮助扩容
if (tab != null && (f instanceof MyConcurrentHashMap.ForwardingNode) &&
(nextTab = ((ForwardingNode<K, V>) f).nextTable) != null) {
//根据数组长度计算得到一个标识符号
int rs = resizeStamp(tab.length);
//如果nextTab和tab没有被并发修改,且sizeCtl < 0[表示正在扩容],
while (nextTab == nextTable && table == tab &&
(sc = sizeCtl) < 0) {
//如果sizeCtl无符号右移16位不等于rs[即若sc的前16位不等于标识符,说明标识符发生了变化.这时将结束执行]
//或者若sc = rs + 1,说明sc此时为非负数,表示此时扩容已结束
//或者sc = rs + 65535[允许的最大帮助线程数量],不在执行
//或者transferIndex <= 0[转移下标发生了调整,扩容结束]
//满足上述一点,结束循环,返回table
if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
sc == rs + MAX_RESIZERS || transferIndex <= 0)
break;
//将SIZECTL + 1,表示此时辅助扩容的线程又多了一个 . SIZECTL为共享变量,可以在其他线程执行时实时读取到.起到线程间通知的效果
if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)) {
//转移节点
transfer(tab, nextTab);
break;
}
}
return nextTab;
}
return table;
}
节点计数器
/**
* 从 putVal 传入的参数是 1, binCount,binCount 默认是0,只有 hash 冲突了才会大于 1.且他的大小是链表的长度(如果不是红黑数结构的话)12
* @param x the count to add
* @param check if <0, don't check resize, if <= 1 only check if uncontended
*/
private final void addCount(long x, int check) {
CounterCell[] as;
long b, s;
//首先if判断counterCells为空并且对当前map对象cas操作baseCount + x成功,就跳过if里的操作,
//因为都cas操作baseCount + x成功了,就不需要通过counterCells辅助了,简单明了。
if ((as = counterCells) != null ||
!U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {
CounterCell a; long v; int m;
boolean uncontended = true;
//如果上面判断失败了,counterCells不为空 或者counterCells为空但cas失败了。
//如果counterCells为空,直接执行fullAddCount。
//如果不为空,判断当前线程在counterCells中的槽位是否为空,如果不为空,
//对槽位中的CounterCell对象cas操作value加1,成功return,失败执行fullAddCount,如果槽位为空,直接执行fullAddCount
if (as == null || (m = as.length - 1) < 0 ||
//ThreadLocalRandom.getProbe()就相当于是 [当前线程的哈希值]
(a = as[ThreadLocalRandom.getProbe() & m]) == null ||
!(uncontended =
//cas对CounterCell对象中的value执行+x(也就是+1)操作
U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))) {
fullAddCount(x, uncontended);
return;
}
if (check <= 1)
return;
s = sumCount();
}
if (check >= 0) {
Node<K, V>[] tab, nt;
int n, sc;
while (s >= (long) (sc = sizeCtl) && (tab = table) != null &&
(n = tab.length) < MAXIMUM_CAPACITY) {
int rs = resizeStamp(n);
if (sc < 0) {
if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
transferIndex <= 0)
break;
if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
transfer(tab, nt);
} else if (U.compareAndSwapInt(this, SIZECTL, sc,
(rs << RESIZE_STAMP_SHIFT) + 2))
transfer(tab, null);
s = sumCount();
}
}
}
判断逻辑如下:
先判断CounterCell数组是否为空:
- 如果为空则对当前map对象cas操作 baseCount 加 1,cas成功了就跳过if,失败了就执行fullAddCount方法
- 如果不为空则通过当前线程的hash值找到此线程在CounterCell数组中对应的位置
- 如果此位置的CounterCell对象为空,就执行fullAddCount方法
- 如果不为空就对此CounterCell对象cas操作value加1
- 如果成功return
- 失败就执行fullAddCount方法
fullAddCount代码块
private final void fullAddCount(long x, boolean wasUncontended) {
int h;
//如果当前线程hash值==0,则重新生成一个hash值。
//当前线程生成的hash值不会改变
if ((h = ThreadLocalRandom.getProbe()) == 0) {
ThreadLocalRandom.localInit(); // force initialization
h = ThreadLocalRandom.getProbe();
wasUncontended = true;
}
boolean collide = false; // True if last slot nonempty
//循环
for (;;) {
CounterCell[] as; CounterCell a; int n; long v;
//如果counterCells已经被初始化了
if ((as = counterCells) != null && (n = as.length) > 0) {
//如果当前线程对应于counterCell数组中的槽位为空
if ((a = as[(n - 1) & h]) == null) {
//如果没有其他线程操作对应counterCell数组中的槽位
if (cellsBusy == 0) {
//counterCell数组中为空的槽位中创建一个CounterCell对象
CounterCell r = new CounterCell(x);
//如果将cellsBusy成功修改成1
if (cellsBusy == 0 &&
U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
boolean created = false;
try {
//再次校验有没有其他线程操作该数组槽位
CounterCell[] rs; int m, j;
if ((rs = counterCells) != null &&
(m = rs.length) > 0 &&
rs[j = (m - 1) & h] == null) {
rs[j] = r;
//标记创建成功
created = true;
}
} finally {
cellsBusy = 0;
}
if (created)
break;
continue; // Slot is now non-empty
}
}
collide = false;
}
//wasUncontended一直为true
else if (!wasUncontended) // CAS already known to fail
wasUncontended = true; // Continue after rehash
//如果当前线程对应槽位已经存在CounterCell元素了,就对value+x
else if (U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))
break;
//不扩容条件
else if (counterCells != as || n >= NCPU)
collide = false; // At max size or stale
//为扩容做条件
else if (!collide)
collide = true;
//一个线程循环两次,都没有加1成功的情况下,数组扩容
//在collide = true的情况下,数组扩容
else if (cellsBusy == 0 &&
U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
try {
if (counterCells == as) {// Expand table unless stale
//扩展数组,长度变为两倍
CounterCell[] rs = new CounterCell[n << 1];
for (int i = 0; i < n; ++i)
rs[i] = as[i];
counterCells = rs;
}
} finally {
cellsBusy = 0;
}
collide = false;
continue; // Retry with expanded table
}
//当前线程重新生成的hash值
h = ThreadLocalRandom.advanceProbe(h);
}
//如果counterCells 没有被初始化,
// cellsBusy==0表示没有其他线程在使用counterCells数组。
else if (cellsBusy == 0 && counterCells == as &&
U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {//表示该数组已经有线程在用
boolean init = false;
try {
//初始化数组
if (counterCells == as) {
//初始化长度为2
CounterCell[] rs = new CounterCell[2];
rs[h & 1] = new CounterCell(x);
counterCells = rs;
init = true;
}
} finally {
//表示当前线程已经操作完成该数组
cellsBusy = 0;
}
if (init)
break;
}
//如果都不满足,则线程自旋去竞争baseCount和CounterCell
else if (U.compareAndSwapLong(this, BASECOUNT, v = baseCount, v + x))
break; // Fall back on using base
}
}
插入树节点
/**
*红黑树结构中新增节点数据
*
* @return null if added
*/
final TreeNode<K, V> putTreeVal(int h, K k, V v) {
Class<?> kc = null;
boolean searched = false;
//从根节点开始寻找
for (TreeNode<K, V> p = root; ; ) {
int dir, ph;
K pk;
if (p == null) {
//若根节点为空,则初始化将数据插入,并跳出循环
first = root = new TreeNode<K, V>(h, k, v, null, null);
break;
} else if ((ph = p.hash) > h)
//若新增数据的hash值<根节点,dir = -1,插入到左子节点
dir = -1;
else if (ph < h)
//若新增数据的hash值> 根节点,dir = 1,插入到右子节点
dir = 1;
else if ((pk = p.key) == k || (pk != null && k.equals(pk)))
//若根节点key同入参key对象地址或者内容相同[如string/int]
return p;
else if ((kc == null &&
(kc = comparableClassFor(k)) == null) ||
(dir = compareComparables(kc, k, pk)) == 0) {
//若key不是对象类型并且未实现compare接口或者dir==0[无法比较两者hash值的大小]
if (!searched) {
TreeNode<K, V> q, ch;
searched = true;
if (((ch = p.left) != null &&
(q = ch.findTreeNode(h, k, kc)) != null) ||
((ch = p.right) != null &&
(q = ch.findTreeNode(h, k, kc)) != null))
//从树结构中左右节点找到匹配的子节点
return q;
}
//对比得到应该往左子树还是右子树中插入
dir = tieBreakOrder(k, pk);
}
TreeNode<K, V> xp = p;
//dir>0 : 往右子节点寻找插入, dir<=0 : 左子节点插入
//子节点为空
if ((p = (dir <= 0) ? p.left : p.right) == null) {
//first:线程共享变量
TreeNode<K, V> x, f = first;
first = x = new TreeNode<K, V>(h, k, v, f, xp);
if (f != null)
f.prev = x;
if (dir <= 0)
xp.left = x;
else
xp.right = x;
if (!xp.red)
//红黑树中不可有两个连续的红节点 . 若xp为黑色 . 则x可标注为红色
x.red = true;
else {
//CAS锁住执行红黑树结构平衡
lockRoot();
try {
//插入后用于维持红黑树结构性质的修复操作,
root = balanceInsertion(root, x);
} finally {
unlockRoot();
}
}
break;
}
}
assert checkInvariants(root);
return null;
}
平衡红黑树的结构
/**
* 插入后用于维持红黑树性质的修复操作,
* @param root
* @param x
* @param <K>
* @param <V>
* @return
*/
static <K,V> TreeNode<K,V> balanceInsertion(TreeNode<K,V> root,
TreeNode<K,V> x) {
x.red = true;//插入的结点设为红色
for (TreeNode<K,V> xp, xpp, xppl, xppr;;) {
if ((xp = x.parent) == null) {
x.red = false;//x的父亲为null代表x是根结点,x改黑色直接结束
return x;
}
else if (!xp.red || (xpp = xp.parent) == null)
return root;//若x的父结点为黑色或者x的父亲为根结点(实际上根应该是黑色)插入红色结点不影响红黑树性质
if (xp == (xppl = xpp.left)) {
if ((xppr = xpp.right) != null && xppr.red) {
//xppr为x的叔叔,且叔叔为红色,x的叔叔和父亲改为红色,x的爷爷改为黑色,x指针上移到爷爷的位置
xppr.red = false;
xp.red = false;
xpp.red = true;
x = xpp;
}
else {
if (x == xp.right) {
//情况2,x的叔叔是黑色且x是右儿子。对x上升至父亲后执行一次左旋
root = rotateLeft(root, x = xp);
xpp = (xp = x.parent) == null ? null : xp.parent;
}
if (xp != null) {
//情况3,x的叔叔是黑色且x是左儿子。x的父亲改黑色,x的爷爷改红色后对x的爷爷进行右旋
xp.red = false;
if (xpp != null) {
xpp.red = true;
root = rotateRight(root, xpp);
}
}
}
}
else {//以下为对称的操作.平衡红黑树的节点数
if (xppl != null && xppl.red) {
xppl.red = false;
xp.red = false;
xpp.red = true;
x = xpp;
}
else {
if (x == xp.left) {
//右旋
root = rotateRight(root, x = xp);
xpp = (xp = x.parent) == null ? null : xp.parent;
}
if (xp != null) {
xp.red = false;
if (xpp != null) {
xpp.red = true;
//左旋
root = rotateLeft(root, xpp);
}
}
}
}
}
}
链表转红黑树
/**
* 数组中index下的链表数据进行树形化转换
*/
private final void treeifyBin(Node<K, V>[] tab, int index) {
Node<K, V> b;
int n, sc;
if (tab != null) {
//若当前数组长度<64.
if ((n = tab.length) < MIN_TREEIFY_CAPACITY)
//n <<1 = n*2 对table进行扩容
tryPresize(n << 1);
else if ((b = tabAt(tab, index)) != null && b.hash >= 0) {
synchronized (b) {
if (tabAt(tab, index) == b) {
TreeNode<K, V> hd = null, tl = null;
//1.取出下标index的数据节点
//2.依次循环将Node节点对象转为TreeNode
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)
//若节点P的父节点数据为空,p为该树结构的头节点
hd = p;
else
//不然,将tl的下节点设置为P
tl.next = p;
//重置tl临时变量,便于下次循环处理prev/next[上下节点指针]
tl = p;
}
//重设数组数据
setTabAt(tab, index, new TreeBin<K, V>(hd));
}
}
}
}
}
数组扩容
/**
* 扩容
*/
private final void tryPresize(int size) {
//size + (size >>> 1) + 1 : 8 + (8/2) + 1
//tableSizeFor : 15->16 . 7->8 . 8->8
int c = (size >= (MAXIMUM_CAPACITY >>> 1)) ? MAXIMUM_CAPACITY :
tableSizeFor(size + (size >>> 1) + 1);
int sc;
while ((sc = sizeCtl) >= 0) {
Node<K, V>[] tab = table;
int n;
//若当前table为空,则初始化,采用CAS算法自旋确保并发
if (tab == null || (n = tab.length) == 0) {
n = (sc > c) ? sc : c;
if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
try {
if (table == tab) {
@SuppressWarnings("unchecked")
Node<K, V>[] nt = (Node<K, V>[]) new Node<?, ?>[n];
table = nt;
sc = n - (n >>> 2);
}
} finally {
sizeCtl = sc;
}
}
} else if (c <= sc || n >= MAXIMUM_CAPACITY)
//若已超出最大值.直接退出
break;
else if (tab == table) {
int rs = resizeStamp(n);
if (sc < 0) {
Node<K, V>[] nt;
if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
transferIndex <= 0)
break;
if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
//数据迁移
transfer(tab, nt);
} else if (U.compareAndSwapInt(this, SIZECTL, sc,
(rs << RESIZE_STAMP_SHIFT) + 2))
transfer(tab, null);
}
}
}
/**
* Integer.numberOfLeadingZeros(n) : 给定一个int类型数据,返回这个数据的二进制串中从最左边算起连续的“0”的总数量。
* 因为int类型的数据长度为32所以高位不足的地方会以“0”填充。
* 1 << (RESIZE_STAMP_BITS - 1) : 1左移一定位数 . 这里RESIZE_STAMP_BITS作为偏移量使用
*/
static final int resizeStamp(int n) {
return Integer.numberOfLeadingZeros(n) | (1 << (RESIZE_STAMP_BITS - 1));
}
get操作
/**
* get方法 . 若key为空 . 抛空指针异常
*/
public V get(Object key) {
Node<K, V>[] tab;
Node<K, V> e, p;
int n, eh;
K ek;
//位运算.求key的hash值
int h = spread(key.hashCode());
//若当前table节点数组不为空,且节点值不为null
if ((tab = table) != null && (n = tab.length) > 0 &&
(e = tabAt(tab, (n - 1) & h)) != null) {
if ((eh = e.hash) == h) {
//两种条件判断 : 1.入参key与数组当前偏移量处的对象地址相同 . 2.对象内容相同,则认为当前节点即为目标节点
if ((ek = e.key) == key || (ek != null && key.equals(ek)))
return e.val;
} else if (eh < 0)
//若目标节点的hash值<0,则从当前节点处,向下寻找,直到满足key的地址相同或者对象内容相同
return (p = e.find(h, key)) != null ? p.val : null;
//hash值相同 , 但不满足对象地址相同或者内容相同的情况下 , 沿着数组当前节点向下[链表或者红黑树]寻找 . 直到满足条件
while ((e = e.next) != null) {
if (e.hash == h && ((ek = e.key) == key || (ek != null && key.equals(ek))))
return e.val;
}
}
return null;
}
size方法
size方法最后返回 baseCount属性 加上CounterCell数组里面的所有值的和
public int size() {
long n = sumCount();
return ((n < 0L) ? 0 :
(n > (long)Integer.MAX_VALUE) ? Integer.MAX_VALUE :
(int)n);
}
//再看看 sumCount()
final long sumCount() {
CounterCell[] as = counterCells; CounterCell a;
long sum = baseCount;
if (as != null) {
for (int i = 0; i < as.length; ++i) {
if ((a = as[i]) != null)
sum += a.value;
}
}
return sum;
}
CounterCell是一个静态内部类,里面的long属性是通过volatile 修饰,来保证并发是当前类型数据的可见性
@sun.misc.Contended static final class CounterCell {
volatile long value;
CounterCell(long x) { value = x; }
}
/**
* Table of counter cells. When non-null, size is a power of 2.
* 计数器单元表。当非空时,大小是2的乘方。
*/
private transient volatile CounterCell[] counterCells;