底层源码分析-ConcurrentHashmap源码详解
JDK7和JDK8 的差异
JDK7保证并发安全的方法
主要利用Unsafe操作+ReentrantLock+分段思想。
-
主要使用了Unsafe操作中的：
- compareAndSwapObject：通过cas的方式修改对象的属性
- putOrderedObject：并发安全的给数组的某个位置赋值
- getObjectVolatile：并发安全的获取数组某个位置的元素
分段思想是为了提高ConcurrentHashMap的并发量，分段数越高则支持的最大并发量越高，程序员可以通过concurrencyLevel参数来指定并发量。ConcurrentHashMap的内部类Segment就是用来表示某一个段的。
每个Segment就是一个小型的HashMap的，当调用ConcurrentHashMap的put方法是，最终会调用到Segment的put方法，而Segment类继承了ReentrantLock，所以Segment自带可重入锁，当调用到Segment的put方法时，会先利用可重入锁加锁，加锁成功后再将待插入的key,value插入到小型HashMap中，插入完成后解锁
JDK8保证并发安全的方法
主要利用Unsafe操作+synchronized关键字。
-
Unsafe操作的使用仍然和JDK7中的类似，主要负责并发安全的修改对象的属性或数组某个位置的值。
synchronized主要负责在需要操作某个位置时进行加锁（该位置不为空），比如向某个位置的链表进行插入结点，向某个位置的红黑树插入结点。
JDK8中其实仍然有分段锁的思想，只不过JDK7中段数是可以控制的，而JDK8中是数组的每一个位置都有一把锁。更加细粒度，较于JDK7
JDK8 putVal()详解
- 通过自旋进行下面四种操作
- **若数组没有被初始化：**tab = initTable() 初始化操作，之后继续自旋
- 若这个位置是空：new 一个对象放入（如果失败自旋继续，如果成功 break）
- 若这个位置的状态是MOVED，也就是现在的table正在扩容，会去helpTransfer(),扩容结束后，继续自旋操作
- 若这个位置有数据，锁住，进行添加操作
- 如果这个节点是链表节点：遍历查找，如果没有，尾插法，有则返回旧值。如果满足阈值，树化
- 如果这个节点是树节点：Tree.putTreeVal()
- addCount(),表内SIZE加一
JDK8 transfer()详解
- 计算每个线程负责转移的个数stride（为了平衡每个线程的压力）
- 如果调用transfer()的第二个参数是null 那么就要初始化nextTab（无参的转移只有一个地方利用cas调用所以无需加锁）
- 创建ForwardingNode 之后备用
- 开始自旋
- 通过一个while(true)： 初始化这个线程需要移动的数组元素节点范围，以及下一个要移动的位置i，以及修改TRANSFERINDEX，剩余迁移数量。
- 通过判断这个线程是否完成任务（并不一定是转移任务完成，可能还有的还在转移）
- 如果是转移任务完成：设置sizeCtl 并return
- 如果只是 这个线程任务完成：将sizeCtl -1
- 如果要转移的位置是空，设置上ForwardingNode，表示转移完成
- 如果要转移的位置f.hash == MOVED 也就是ForwardingNode ，也就是表示转移完成，进行下一个。
- 如果有元素，加锁开始转移。
- 如果是链表：
- 遍历链表，lastRun为当前链表上runbit连续相同的一小段的最后一段
- 如果最后一段的runBit为0，则则该段应该保持在当前位置
- 从头节点开始，遍历链表到lastRun结束，一个一个添加到newTab中。
- 将oldTab[i]设置为ForwardingNode节点，表示转移完成
- 如果是树节点：
- 由于树也有双链连接，所以可以当链表遍历为两条链表。
- 如果链表长度小于阈值，那么链表化，否则判断一个另一个是不是空如果是，直接使用，否则，树化。
- 如果是链表：
JDK8 addCount()
- 通过CAS试图更新baseCount（+1）
- 成功：去check（）
- 失败：通过CAS尝试更新对应CELL的CELLVALUE，失败调用fullAddCount方法。
- 添加成功之后，通过统计shul，判断是否大于阈值，是否要扩容。并且通过一个循环去让更多线程去扩容。
JDK8 fullAddCount()
- 属性cellsBusy：观察是否对整个Cells是否在完成某件事
- 自旋操作：
- CounterCell[]不为空
- 如果对应的为空
- 获取锁，new Cell() break；
- 如果不为空
- 利用CAS 设置Values （+1）
- 如果发生线程碰撞，扩容。
- 如果对应的为空
- CounterCell[] 为空，设置 CELLSBUSY 为1
- 初始化table，break。
- 设置 CELLSBUSY 为0，
- CounterCell[]不为空
ConcurrentHashmap数据结构和实现原理
JDK7
基于ReentrantLock实现分段锁
- 可以看成对于每一个segment下都维护着一个HashMap。不过这样击中同一个segment的线程是有竞争的，粒度较大。
JDK8
ConcurrentHashMap基于分段锁+CAS保证线程安全，分段锁基于synchronized关键字实现.
- 主要利用CAS 去获取每个Node上的使用权，然后利用synchronized锁进行一些较长的写操作。
重要域
-
LOAD_FACTOR: 负载因子, 默认75%, 当table使用率达到75%时, 为减少table的hash碰撞, tabel长度将扩容一倍。负载因子计算: 元素总个数%table.lengh
-
TREEIFY_THRESHOLD: 树化阈值，默认8, 当链表长度达到8时, 将结构转变为红黑树。
-
UNTREEIFY_THRESHOLD: 默认6, 红黑树转变为链表的阈值。
-
MIN_TRANSFER_STRIDE: 默认16, table扩容时, 每个线程最少迁移table的槽位个数。
-
MOVED: 值为-1, 当Node.hash为MOVED时, 代表着table正在扩容
-
TREEBIN, 置为-2, 代表此元素后接红黑树。
-
nextTable: table迁移过程临时变量, 在迁移过程中将元素全部迁移到nextTable上。
-
sizeCtl: 用来标志table初始化和扩容的,不同的取值代表着不同的含义:
- 0: table还没有被初始化
- -1: table正在初始化
- 小于-1: 实际值为resizeStamp(n)<<RESIZE_STAMP_SHIFT+2, 表明table正在扩容
- 大于0: 初始化完成后, 代表table最大存放元素的个数, 默认为0.75*n
-
transferIndex: table容量从n扩到2n时, 是从索引n->1的元素开始迁移, transferIndex代表当前已经迁移的元素下标
-
ForwardingNode: 一个特殊的Node节点, 其hashcode=MOVED, 代表着此时table正在做扩容操作。扩容期间, 若table某个元素为null, 那么该元素设置为ForwardingNode, 当下个线程向这个元素插入数据时, 检查hashcode=MOVED, 就会帮着扩容。
重要方法
put()
final V putVal(K key, V value, boolean onlyIfAbsent) {
//key 和 value 不可为null
if (key == null || value == null) throw new NullPointerException();
//将HashCode做了一些处理减少冲突
int hash = spread(key.hashCode());
int binCount = 0;
//这里利用CAS自旋去添加Key
for (Node<K,V>[] tab = table;;) {
Node<K,V> f; int n, i, fh;
//若还未初始化，先初始化table
if (tab == null || (n = tab.length) == 0)
//初始化数组
tab = initTable();
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
//去尝试 如果空的话则new一个对象：casTabAt是一个CAS的方法
if (casTabAt(tab, i, null,
new Node<K,V>(hash, key, value, null)))
break;//若添加成功则退出自旋
}//如果在访问的节点是MOVED 模式
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) {
//判断是不是要树化 因为树化可以另外脱离 所以 treeifyBin 自己里面有锁
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) {\
//这里利用好了 sizeCtl 这个状态参数 来实现无锁并发。
//小于0 说明这个table 正在初始化或者正在扩容，释放cpu
if ((sc = sizeCtl) < 0)
Thread.yield(); // 释放
// 尝试拿到新建table的锁。若成功，则去创建有且仅有一条能进这个if
else if (U.compareAndSwapInt(this, SIZECTL, sc, -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);1
}
} finally {
sizeCtl = sc;
}
break;
}
}
return tab;
}
transfer() 扩容方法
private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
int n = tab.length, stride;
// stride表示步长，步长最小为16，如果CPU只有一核，那么步长为n
// 既如果只有一个cpu,那么只有一个线程来进行扩容
// 步长代表一个线程负责转移的桶的个数
if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
stride = MIN_TRANSFER_STRIDE; // subdivide range
// 新数组初始化，长度为两倍
//由于nextTab =null 只有一个线程进来所以无需并发锁。
if (nextTab == null) { // initiating
try {
@SuppressWarnings("unchecked")
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表示第二个小数组的第一个元素的下标
transferIndex = n;
}
// 新数组的长度
int nextn = nextTab.length;
//创建一个fwd 对象，会放置已被转移成功的Node
ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
//当前节点是否转移成功，是否继续转移下一个点
boolean advance = true;
// 是否完成全部节点的扩容
boolean finishing = false;
// 开始转移
for (int i = 0, bound = 0;;) {
Node<K,V> f; int fh;
//对这个线程安排要转移的节点区间[bound, i)，bound 和i的值
while (advance) {
int nextIndex, nextBound;
//本线程处理的区间范围为[bound, i),范围还没有处理完成，会设置为false 重新设置区间
if (--i >= bound || finishing)
advance = false;
// transferIndex <= 0 说明转移完成了
else if ((nextIndex = transferIndex) <= 0) {
i = -1;
advance = false;
}
// 通过cas来修改TRANSFERINDEX，如果修改成功则对bound和i进行赋值。
else if (U.compareAndSwapInt
(this, TRANSFERINDEX, nextIndex,
nextBound = (nextIndex > stride ?
nextIndex - stride : 0))) {
bound = nextBound;
i = nextIndex - 1;
advance = false;
}
}
// i表示一个步长里的最大下标, 如果i小于或者大于等于老数组长度，或者下标+老数组长度大于等等新数组长度。说明这个线程已经完成自己的任务
if (i < 0 || i >= n || i + n >= nextn) {
int sc;
// 这个线程转移完成
if (finishing) {
nextTable = null;
table = nextTab;
// sizeCtl = 1.5n = 2n*0.75
sizeCtl = (n << 1) - (n >>> 1);
return;
}
// 每个线程负责的转移任务结束后利用cas来对sizeCtl减1
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
}
}
// 从i位置开始转移元素
// 如果老数组的i位置元素为null,则表示该位置上的元素已经被转移完成了，
// 则通过cas设置为ForwardingNode，表示无需转移
else if ((f = tabAt(tab, i)) == null)
advance = casTabAt(tab, i, null, fwd);
// 如果i位置已经是ForwardingNode，则跳过该位置（就是桶）
else if ((fh = f.hash) == MOVED)
advance = true; // already processed
else {
// 加锁，开始转移
synchronized (f) {
// 加锁完了之后再次检查一遍tab[i]是否发生了变化
if (tabAt(tab, i) == f) {
Node<K,V> ln, hn;
// fh大于等于0表示是链表
if (fh >= 0) {
// n是老数组的长度
// 因为n是2的幂次方数，所以runbit只有两种结果:0和n
int runBit = fh & n;
// 遍历链表，lastRun为当前链表上runbit连续相同的一小段的最后一段
Node<K,V> lastRun = f;
for (Node<K,V> p = f.next; p != null; p = p.next) {
int b = p.hash & n;
if (b != runBit) {
runBit = b;
lastRun = p;
}
}
// 如果最后一段的runBit为0，则则该段应该保持在当前位置
// 否则应该设置到i+n位置
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;
// 如果ph & n，则将遍历到的节点插入到ln的前面
// 否则将遍历到的节点插入到hn的前面
if ((ph & n) == 0)
ln = new Node<K,V>(ph, pk, pv, ln);
else
hn = new Node<K,V>(ph, pk, pv, hn);
}
// 将ln链表赋值在新tab的i位置
setTabAt(nextTab, i, ln);
// 将hn链表赋值在新tab的i+n位置
setTabAt(nextTab, i + n, hn);
// 这是老tab的i位置ForwardingNode节点，表示转移完成
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;
}
}
}
}
}
}
helpTransfer()
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);
while (nextTab == nextTable && table == tab &&
(sc = sizeCtl) < 0) {//说明还在扩容
//判断是否标志发生了变化|| 扩容结束了
if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
sc == rs + MAX_RESIZERS || transferIndex <= 0)
//达到最大的帮助线程 || 判断扩容转移下标是否在调整（扩容结束）
break;
// 将 sizeCtl + 1, （表示增加了一个线程帮助其扩容）
if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)) {
transfer(tab, nextTab);
break;
}
}
return nextTab;
}
return table;
}
addCount()
private final void addCount(long x, int check) {
// 先通过CAS更新baseCount（+1）
// 如果更新失败则通过CAS更新CELLVALUE
// 如果仍然失败则调用fullAddCount
// as是一个CounterCell数组，一个CounterCell对象表示一个计数器，
// 多个线程在添加元素时，手写都会尝试去更新baseCount，那么只有一个线程能更新成功，另外的线程将更新失败
// 那么其他的线程就利用一个CounterCell对象来记一下数
CounterCell[] as; long b, s;
if ((as = counterCells) != null ||
!U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {
// 某个线程更新baseCount失败了
CounterCell a; long v; int m;
boolean uncontended = true;
// 如果CounterCell[]是null
// 或者CounterCell[]不为null的情况下CounterCell[]的长度小于1也就是等于0，
// 或者CounterCell[]长度不为0的情况下随机计算一个CounterCell[]的下标，并判断此下标位置是否为空
// 或者CounterCell[]中的某下标位置不为null的情况下通过cas修改CounterCell中的值失败了
// 才调用fullAddCount方法，然后返回
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;
}
// 如果修改CELLVALUE成功了，这里的check就是binCount，这里为什么要判断小于等于1
if (check <= 1)
return;
// 如果修改CELLVALUE成功了，则统计ConcurrentHashMap的元素个数
s = sumCount();
}
if (check >= 0) {
Node<K,V>[] tab, nt; int n, sc;
// 如果元素个数大于等于了阈值或-1就自旋扩容
while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&
(n = tab.length) < MAXIMUM_CAPACITY) {
// resizeStamp这个方法太难理解，反正就是返回一个数字，比如n=16,rs则=32795
int rs = resizeStamp(n);
// 如果sc小于0,表示已经有其他线程在进行扩容了，sc+1
if (sc < 0) {
// 如果全部元素已经转移完了，或者已经达到了最大并发扩容数限制则breack
if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
transferIndex <= 0)
break;
// 如果没有，则sizeCtl加1，然后进行转移元素
if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
transfer(tab, nt);
}
// 如果sc是大于0的并且如果修改sizeCtl为一个特定的值，比如n=16, rs << RESIZE_STAMP_SHIFT) + 2= -2145714174
else if (U.compareAndSwapInt(this, SIZECTL, sc,
(rs << RESIZE_STAMP_SHIFT) + 2))
// 转移元素，转移完了之后继续进入循环中
transfer(tab, null);
s = sumCount();
}
}
}
fullAddCount()
private final void fullAddCount(long x, boolean wasUncontended) {
int h;
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) {
// h可以理解为当前线程的hashcode，如果对应的counterCells数组下标位置元素当前是空的
// 那么则应该在该位置去生成一个CounterCell对象
if ((a = as[(n - 1) & h]) == null) {
// counterCells如果空闲
if (cellsBusy == 0) { // Try to attach new Cell
// 生成CounterCell对象
CounterCell r = new CounterCell(x); // Optimistic create
// 再次判断counterCells如果空闲，并且cas成功修改cellsBusy为1
if (cellsBusy == 0 &&
U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
boolean created = false;
try { // Recheck under lock
CounterCell[] rs; int m, j;
// 如果counterCells对象没有发生变化，那么就将刚刚创建的CounterCell赋值到数组中
if ((rs = counterCells) != null &&
(m = rs.length) > 0 &&
rs[j = (m - 1) & h] == null) {
rs[j] = r;
// 便是CounterCell创建成功
created = true;
}
} finally {
cellsBusy = 0;
}
// 如果CounterCell创建成功，则退出循环，方法执行结束
if (created)
break;
// 如果没有创建成功，则继续循环
continue; // Slot is now non-empty
}
}
// 应该当前位置为空，所以肯定没有发生碰撞
collide = false;
}
// 如果当前位置不为空，则进入以下分支判断
// 如果调用当前方法之前cas失败了，那么先将wasUncontended设置为true，
else if (!wasUncontended) // CAS already known to fail
wasUncontended = true; // Continue after rehash
// 通过cas修改CELLVALUE的值，修改成功则退出循环，修改失败则继续进行分支判断
else if (U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))
break;
// counterCells发生了改变，或者当前counterCells数组的大小大于等于CPU核心数，设置collide为false，
// 如果到了这个极限，counterCells不会再进行扩容了
else if (counterCells != as || n >= NCPU)
collide = false; // At max size or stale
// 一旦走到这个分支了，那么就是发生了碰撞了，一个当前这个位置不为空
else if (!collide)
collide = true;
// 当collide为true进入这个分支，表示发生了碰撞会进行扩容
else if (cellsBusy == 0 &&
U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
try {
// 对counterCells进行扩容
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没有线程在用
// 如果counterCells空闲，并且当前线程所获得counterCells对象没有发生变化
// 先通过CAS将cellsBusy标记改为1，如果修改成功则证明可以操作counterCells了，
// 其他线程暂时不能使用counterCells
else if (cellsBusy == 0 && counterCells == as &&
U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
boolean init = false;
try { // Initialize table
// cellsBusy标记改成后就初始化CounterCell[]
if (counterCells == as) {
CounterCell[] rs = new CounterCell[2];
// 并且把x赋值到CounterCell中完成计数
rs[h & 1] = new CounterCell(x);
counterCells = rs;
init = true;
}
} finally {
cellsBusy = 0;
}
// 如果没有初始化成功，则证明counterCells发生了变化，当前线程修改cellsBusy的过程中，
// 可能其他线程已经把counterCells对象替换掉了
// 如果初始化成功，则退出循环，方法执行结束
if (init)
break;
}
else if (U.compareAndSwapLong(this, BASECOUNT, v = baseCount, v + x))
break; // Fall back on using base
}
}
扫一扫
380
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
