1. ConcurrentHashMap
- 相关属性
//最大容量 2的30次幂
private static final int MAXIMUM_CAPACITY = 1 << 30;
//默认初始容量
private static final int DEFAULT_CAPACITY = 16;
//数组的最大容量,主要是toArray()方法使用
static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
//并发数,jdk1.8不使用
private static final int DEFAULT_CONCURRENCY_LEVEL = 16;
//加载因子
private static final float LOAD_FACTOR = 0.75f;
//当链表中节点数大于8时转红黑树
static final int TREEIFY_THRESHOLD = 8;
//当红黑树节点数小于6时转成链表
static final int UNTREEIFY_THRESHOLD = 6;
//节点的hash属性为MOVED时,表示map正在扩容
static final int MOVED = -1;
//为-2, 代表此元素后接红黑树
static final int TREEBIN = -2;
static final int RESERVED = -3;
//主要用来计算Hash值的
static final int HASH_BITS = 0x7fffffff;
// 这是扩容时的标记节点,主要在扩容时使用
ForwardingNode
//容器的计数器,没有竞争时可以表示容器中元素长度
private transient volatile long baseCount;
/**
* -1 时表示正在初始化
* tab.length*LOAD_FACTOR(因子 0.75) 时表示初始化完成
**/
private transient volatile int sizeCtl;
-
put方法,jdk1.8ConcurrentHashMap是基于cas和synchronized实现线程安全
- putVal(K key, V value, boolean onlyIfAbsent)方法
final V putVal(K key, V value, boolean onlyIfAbsent) { //对key和value做校验 if (key == null || value == null) throw new NullPointerException(); int hash = spread(key.hashCode()); int binCount = 0; for (Node<K,V>[] tab = table;;) {//死循环 // f是头节点 Node<K,V> f; int n, i, fh; if (tab == null || (n = tab.length) == 0)//如果数组没有初始化,则初始化数组 tab = initTable(); else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {//获取当前tab中i下标的node,其实是链表或红黑树头节点 //cas操作,如果当前tab在i下标上的头节点为null,创建新的node添加到i下标处,成功后跳出死循环,不成功继续下一轮循环 if (casTabAt(tab, i, null,new Node<K,V>(hash, key, value, null))) break; } else if ((fh = f.hash) == MOVED)//帮助扩容 tab = helpTransfer(tab, f); else { //链表的处理 V oldVal = null; //为f即头节点上锁 synchronized (f) { //再次校验最新获取的node是否与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; } //先将e赋值给pred,然后e=e.next;一直循环到当前的链表的最后一个节点,然后将新的key value创建新的node,追加到当前链表的最后。 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; } } } } //表示当前key value添加成功了 if (binCount != 0) { //判断是否需要转红黑树 if (binCount >= TREEIFY_THRESHOLD) treeifyBin(tab, i); if (oldVal != null) return oldVal; break; } } } //元素添加完成后,统计数量,并且校验是否需要扩容 addCount(1L, binCount); return null; }
- initTable() 方法
private final Node<K,V>[] initTable() { Node<K,V>[] tab; int sc; while ((tab = table) == null || tab.length == 0) { //表示已经在初始化,让出cpu资源,直到tab初始化完成后跳出循环 if ((sc = sizeCtl) < 0) //yield() 让出cpu资源后会再次竞争cpu资源 Thread.yield(); else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {//cas操作,将-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; //这种计算方式其实等同于n*0.75(加载因子) sc = n - (n >>> 2); } } finally { sizeCtl = sc; } break; } } return tab; }
- casTabAt(Node<K,V>[] tab, int i,Node<K,V> c, Node<K,V> v)
//使用cas在tab的下标为i处添加node,即为头节点 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); }
- final Node<K,V>[] helpTransfer(Node<K,V>[] tab, Node<K,V> f)帮助扩容的方法,主要将多个线程分散在不同的数组下标区间
final Node<K,V>[] helpTransfer(Node<K,V>[] tab, Node<K,V> f) { Node<K,V>[] nextTab; int sc; //当满足如下条件才可以进行扩容 if (tab != null && (f instanceof ForwardingNode) && (nextTab = ((ForwardingNode<K,V>)f).nextTable) != null) { int rs = resizeStamp(tab.length); //循环,使用cas形成自旋锁 while (nextTab == nextTable && table == tab && (sc = sizeCtl) < 0) { if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 || sc == rs + MAX_RESIZERS || transferIndex <= 0) break; if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)) { //扩容 transfer(tab, nextTab); break; } } return nextTab; } return table; }
- private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab)扩容方法,主要采用了高低 位算法
private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) { int n = tab.length, stride; if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE) stride = MIN_TRANSFER_STRIDE; // subdivide range if (nextTab == null) {// 初始化新数组 try { //n << 1 新数组的长度为之前的2倍 Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1]; nextTab = nt; } catch (Throwable ex) { // try to cope with OOME sizeCtl = Integer.MAX_VALUE; return; } nextTable = nextTab; transferIndex = n; } int nextn = nextTab.length; //创建一个占位node,标记当前map正在扩容 ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab); boolean advance = true; boolean finishing = false; // to ensure sweep before committing nextTab for (int i = 0, bound = 0;;) { Node<K,V> f; int fh; while (advance) { int nextIndex, nextBound; if (--i >= bound || finishing) advance = false; else if ((nextIndex = transferIndex) <= 0) { i = -1; advance = false; } else if (U.compareAndSwapInt (this, TRANSFERINDEX, nextIndex, nextBound = (nextIndex > stride ? nextIndex - stride : 0))) { bound = nextBound; i = nextIndex - 1; advance = false; } } if (i < 0 || i >= n || i + n >= nextn) { int sc; if (finishing) { nextTable = null; table = nextTab; sizeCtl = (n << 1) - (n >>> 1); return; } if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) { if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT) return; finishing = advance = true; i = n; // recheck before commit } } else if ((f = tabAt(tab, i)) == null) advance = casTabAt(tab, i, null, fwd); else if ((fh = f.hash) == MOVED) advance = true; // already processed else { synchronized (f) { if (tabAt(tab, i) == f) { //ln,低位节点,此节点不会在扩容时变换所在数组下标 //hn 高位节点,此节点在扩容时会向后移动,在数组的新下标为当前下标+扩容长度 Node<K,V> ln, hn; if (fh >= 0) { // 这里面之所以这么算,是因为map扩容时采用了高低位算法,后续会讲解高低位算法 int runBit = fh & n; Node<K,V> lastRun = f; //lastRun默认是链表头节点,循环链表,是为了判断当前链表是否全部符合ln或hn for (Node<K,V> p = f.next; p != null; p = p.next) { int b = p.hash & n; if (b != runBit) { runBit = b; lastRun = p; } } if (runBit == 0) { ln = lastRun; hn = null; } else { hn = lastRun; ln = null; } //如果当前链表的头节点不等于lastRun,说明此链表中存在需要移动的节点。重新构建节点 for (Node<K,V> p = f; p != lastRun; p = p.next) { int ph = p.hash; K pk = p.key; V pv = p.val; if ((ph & n) == 0) ln = new Node<K,V>(ph, pk, pv, ln); else hn = new Node<K,V>(ph, pk, pv, hn); } //将ln和hn放在新数组相应下标处 setTabAt(nextTab, i, ln); setTabAt(nextTab, i + n, hn); //将占位节点放到老数组i下标处 setTabAt(tab, i, fwd); advance = true; } //红黑树处理 else if (f instanceof TreeBin) { TreeBin<K,V> t = (TreeBin<K,V>)f; TreeNode<K,V> lo = null, loTail = null; TreeNode<K,V> hi = null, hiTail = null; int lc = 0, hc = 0; for (Node<K,V> e = t.first; e != null; e = e.next) { int h = e.hash; TreeNode<K,V> p = new TreeNode<K,V> (h, e.key, e.val, null, null); if ((h & n) == 0) { if ((p.prev = loTail) == null) lo = p; else loTail.next = p; loTail = p; ++lc; } else { if ((p.prev = hiTail) == null) hi = p; else hiTail.next = p; hiTail = p; ++hc; } } ln = (lc <= UNTREEIFY_THRESHOLD) ? untreeify(lo) : (hc != 0) ? new TreeBin<K,V>(lo) : t; hn = (hc <= UNTREEIFY_THRESHOLD) ? untreeify(hi) : (lc != 0) ? new TreeBin<K,V>(hi) : t; setTabAt(nextTab, i, ln); setTabAt(nextTab, i + n, hn); setTabAt(tab, i, fwd); advance = true; } } } } } }
- 高低位算法
int runBit = fh & n;头节点的hash值&原数组的长度,如果等于0则节点迁移时保持在数组原下标处否则需要迁移,迁移的新下标为当前下标+扩容长度。主要与获取节点所在数组下标的位置的算法有关即i = (n - 1) & hash 如图:图(a)表示扩容前的key1和key2两种key确定索引位置的示例,图(b)表示扩容后key1和key2两种key确定索引位置的示例,其中hash1是key1对应的哈希与高位运算结果。元素在重新计算hash之后,因为n变为2倍,那么n-1的mask范围在高位多1bit(红色),因此新的index就会发生这样的变化 那么这句话的意思是什么呢,通过计算可知,任意一个数&2的n次幂要么等于0要么等于2的n次幂。当等于0的数刚好通过 i = (n - 1)& hash计算出的下标刚好是扩容前的下标。不等于0的数再通过计算后得到的下标刚好是扩容前下标+扩容的长度。
- private final void addCount(long x, int check),添加计数并校验是否需要扩容
private final void addCount(long x, int check) { //CounterCell计数器数组 CounterCell[] as; long b, s; //cas操作,为baseCount赋值 if ((as = counterCells) != null || !U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) { CounterCell a; long v; int m; boolean uncontended = true; //随机从as数组中获取CounterCell,并为CounterCell中value属性cas赋值 if (as == null || (m = as.length - 1) < 0 || (a = as[ThreadLocalRandom.getProbe() & m]) == null || !(uncontended = 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; //s >= (long)(sc = sizeCtl)表示需要扩容 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(); } } }