mysql http_put_洪永佳 - SegmentFault 思否
源碼解析
put方法源碼public V put(K key, V value) {
return putVal(key, value, false);
}
/** Implementation for put and putIfAbsent */
final V putVal(K key, V value, boolean onlyIfAbsent) {
if (key == null || value == null) throw new NullPointerException();
int hash = spread(key.hashCode()); //計(jì)算hash值
int binCount = 0;//用來記錄鏈表的長(zhǎng)度
for (Node[] tab = table;;) {//這里其實(shí)就是自旋操作，當(dāng)出現(xiàn)線程競(jìng)爭(zhēng)時(shí)不斷自旋
Node f; int n, i, fh;
if (tab == null || (n = tab.length) == 0)//如果數(shù)組為空，則進(jìn)行數(shù)組初始化
tab = initTable();//初始化數(shù)組
// 通過hash值對(duì)應(yīng)的數(shù)組下標(biāo)得到第一個(gè)節(jié)點(diǎn); 以volatile讀的方式來讀取table數(shù)組中的元素，保證每次拿到的數(shù)據(jù)都是最新的
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
//如果該下標(biāo)返回的節(jié)點(diǎn)為空，則直接通過cas將新的值封裝成node插入即可；如果cas失敗，說明存在競(jìng)爭(zhēng)，則進(jìn)入下一次循環(huán)
if (casTabAt(tab, i, null,
new Node(hash, key, value, null)))
break; // no lock when adding to empty bin
}
else if ((fh = f.hash) == MOVED)
tab = helpTransfer(tab, f);//協(xié)助擴(kuò)容
else {//進(jìn)入到這個(gè)分支，說明f是當(dāng)前nodes數(shù)組對(duì)應(yīng)位置節(jié)點(diǎn)的頭節(jié)點(diǎn)，并且不為空
V oldVal = null;
synchronized (f) {//給對(duì)應(yīng)的頭結(jié)點(diǎn)加鎖
if (tabAt(tab, i) == f) {//再次判斷對(duì)應(yīng)下標(biāo)位置是否為f節(jié)點(diǎn)
if (fh >= 0) {//頭結(jié)點(diǎn)的hash值大于0，說明是鏈表
binCount = 1;//用來記錄鏈表的長(zhǎng)度
for (Node e = f;; ++binCount) {//遍歷鏈表
K ek;
//如果發(fā)現(xiàn)相同的key，則判斷是否需要進(jìn)行值的覆蓋
if (e.hash == hash &&
((ek = e.key) == key ||
(ek != null && key.equals(ek)))) {
oldVal = e.val;
if (!onlyIfAbsent)//默認(rèn)情況下，直接覆蓋舊的值
e.val = value;
break;
}
//一直遍歷到鏈表的最末端，直接把新的值加入到鏈表的最后面
Node pred = e;
if ((e = e.next) == null) {
pred.next = new Node(hash, key,
value, null);
break;
}
}
}
//如果當(dāng)前的f節(jié)點(diǎn)是一顆紅黑樹
else if (f instanceof TreeBin) {
Node p;
binCount = 2;
//則調(diào)用紅黑樹的插入方法插入新的值
if ((p = ((TreeBin)f).putTreeVal(hash, key,
value)) != null) {
oldVal = p.val;//同樣，如果值已經(jīng)存在，則直接替換
if (!onlyIfAbsent)
p.val = value;
}
}
}
}
if (binCount != 0) {//說明上面在做鏈表操作
//如果鏈表長(zhǎng)度已經(jīng)達(dá)到臨界值8 就需要把鏈表轉(zhuǎn)換為樹結(jié)構(gòu)
if (binCount >= TREEIFY_THRESHOLD)
treeifyBin(tab, i);
if (oldVal != null)//如果val是被替換的，則返回替換之前的值
return oldVal;
break;
}
}
}
//將當(dāng)前ConcurrentHashMap的元素?cái)?shù)量加1，有可能觸發(fā)transfer操作(擴(kuò)容)
addCount(1L, binCount);
return null;
}
spread計(jì)算Hash值static final int spread(int h) {
return (h ^ (h >>> 16)) & HASH_BITS;
}
initTable初始化表格private final Node[] initTable() {
Node[] tab; int sc;
while ((tab = table) == null || tab.length == 0) {
if ((sc = sizeCtl) < 0) //被其他線程搶占了初始化的操作,則直接讓出自己的CPU時(shí)間片
Thread.yield(); // lost initialization race; just spin
else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
//通過cas操作，將sizeCtl替換為-1，標(biāo)識(shí)當(dāng)前線程搶占到了初始化資格
try {
if ((tab = table) == null || tab.length == 0) {
int n = (sc > 0) ? sc : DEFAULT_CAPACITY;//默認(rèn)初始容量為16
@SuppressWarnings("unchecked")
//初始化數(shù)組，長(zhǎng)度為16，或者初始化在構(gòu)造ConcurrentHashMap的時(shí)候傳入的長(zhǎng)度
Node[] nt = (Node[])new Node,?>[n];
table = tab = nt;//將這個(gè)數(shù)組賦值給table
sc = n - (n >>> 2);//計(jì)算下次擴(kuò)容的大小，實(shí)際就是當(dāng)前容量的0.75倍，這里使用了右移來計(jì)算
}
} finally {
sizeCtl = sc;//設(shè)置sizeCtl為sc, 如果默認(rèn)是16的話，那么這個(gè)時(shí)候sc=16*0.75=12
}
break;
}
}
return tab;
}
tabAt計(jì)算下標(biāo)static final Node tabAt(Node[] tab, int i) {
return (Node)U.getObjectVolatile(tab, ((long)i << ASHIFT) + ABASE);
}
addCount計(jì)數(shù)private final void addCount(long x, int check) {
CounterCell[] as; long b, s;
//判斷counterCells是否為空，
// 1. 如果為空，就通過cas操作嘗試修改baseCount變量，對(duì)這個(gè)變量進(jìn)行原子累加操作(做這個(gè)操作的意義是：如果在沒有競(jìng)爭(zhēng)的情況下，仍然采用baseCount來記錄元素個(gè)數(shù))
// 2. 如果cas失敗說明存在競(jìng)爭(zhēng)，這個(gè)時(shí)候不能再采用baseCount來累加，而是通過CounterCell來記錄
if ((as = counterCells) != null ||
!U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {
CounterCell a; long v; int m;
boolean uncontended = true;//是否沖突標(biāo)識(shí)，默認(rèn)為沒有沖突
//這里有幾個(gè)判斷
// 1. 計(jì)數(shù)表為空則直接調(diào)用fullAddCount
// 2. 從計(jì)數(shù)表中隨機(jī)取出一個(gè)數(shù)組的位置為空，直接調(diào)用fullAddCount
// 3. 通過CAS修改CounterCell隨機(jī)位置的值，如果修改失敗說明出現(xiàn)并發(fā)情況(這里又用到了一種巧妙的方法)，
// 調(diào)用fullAndCount Random在線程并發(fā)的時(shí)候會(huì)有性能問題以及可能會(huì)產(chǎn)生相同的隨機(jī)數(shù),ThreadLocalRandom.getProbe可以解決這個(gè)問題，并且性能要比Random高
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)//鏈表長(zhǎng)度小于等于1，不需要考慮擴(kuò)容
return;
s = sumCount();//統(tǒng)計(jì)ConcurrentHashMap元素個(gè)數(shù)
}
if (check >= 0) {//如果binCount>=0，標(biāo)識(shí)需要檢查擴(kuò)容
Node[] tab, nt; int n, sc;
//s標(biāo)識(shí)集合大小，如果集合大小大于或等于擴(kuò)容閾值(默認(rèn)值的0.75)
// 并且table不為空并且table的長(zhǎng)度小于最大容量
while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&
(n = tab.length) < MAXIMUM_CAPACITY) {
int rs = resizeStamp(n);//這里是生成一個(gè)唯一的擴(kuò)容戳
if (sc < 0) {
//sc<0，也就是sizeCtl<0，說明已經(jīng)有別的線程正在擴(kuò)容了
// 這5個(gè)條件只要有一個(gè)條件為true，說明當(dāng)前線程不能幫助進(jìn)行此次的擴(kuò)容，直接跳出循環(huán)
// sc >>> RESIZE_STAMP_SHIFT!=rs 表示比較高RESIZE_STAMP_BITS位生成戳和rs是否相等，相同
// sc=rs+1 表示擴(kuò)容結(jié)束
// sc==rs+MAX_RESIZERS 表示幫助線程線程已經(jīng)達(dá)到最大值了
// nt=nextTable -> 表示擴(kuò)容已經(jīng)結(jié)束
// transferIndex<=0 表示所有的transfer任務(wù)都被領(lǐng)取完了，沒有剩余的hash桶來給自己自己好這個(gè)線程來做transfer
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))//當(dāng)前線程嘗試幫助此次擴(kuò)容，如果成功，則調(diào)用transfer
transfer(tab, nt);
}
//如果當(dāng)前沒有在擴(kuò)容，那么 rs 肯定是一個(gè)正數(shù)，通過 rs <
// 為一個(gè)負(fù)數(shù)， 2 表示有一個(gè)線程在執(zhí)行擴(kuò)容
else if (U.compareAndSwapInt(this, SIZECTL, sc,
(rs << RESIZE_STAMP_SHIFT) + 2))
transfer(tab, null);
s = sumCount();// 重新計(jì)數(shù)，判斷是否需要開啟下一輪擴(kuò)容
}
}
}
sumCount計(jì)數(shù)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;
}
fullAddCount源碼分析private final void fullAddCount(long x, boolean wasUncontended) {
int h;
//獲取當(dāng)前線程的probe的值，如果值為0，則初始化當(dāng)前線程的probe的值,probe就是隨機(jī)數(shù)
if ((h = ThreadLocalRandom.getProbe()) == 0) {
ThreadLocalRandom.localInit(); // force initialization
h = ThreadLocalRandom.getProbe();
wasUncontended = true;// 由于重新生成了probe，未沖突標(biāo)志位設(shè)置為true
}
boolean collide = false; // True if last slot nonempty
for (;;) {
CounterCell[] as; CounterCell a; int n; long v;
//說明counterCells已經(jīng)被初始化過了
if ((as = counterCells) != null && (n = as.length) > 0) {
if ((a = as[(n - 1) & h]) == null) {//通過該值與當(dāng)前線程probe求與，獲得cells的下標(biāo)元素，和hash 表獲取索引是一樣的
if (cellsBusy == 0) { // Try to attach new Cell //cellsBusy=0表示counterCells不在初始化或者擴(kuò)容狀態(tài)下
CounterCell r = new CounterCell(x); // Optimistic create //構(gòu)造一個(gè)CounterCell的值，傳入元素個(gè)數(shù)
if (cellsBusy == 0 && //通過cas設(shè)置cellsBusy標(biāo)識(shí)，防止其他線程來對(duì)counterCells并發(fā)處理
U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
boolean created = false;
try { // Recheck under lock
CounterCell[] rs; int m, j;
//將初始化的r對(duì)象的元素個(gè)數(shù)放在對(duì)應(yīng)下標(biāo)的位置
if ((rs = counterCells) != null &&
(m = rs.length) > 0 &&
rs[j = (m - 1) & h] == null) {
rs[j] = r;
created = true;
}
} finally {//恢復(fù)標(biāo)志位
cellsBusy = 0;
}
if (created)//創(chuàng)建成功，退出循環(huán)
break;
continue; // Slot is now non-empty //說明指定cells下標(biāo)位置的數(shù)據(jù)不為空，則進(jìn)行下一次循環(huán)
}
}
collide = false;
}
//說明在addCount方法中cas失敗了，并且獲取probe的值不為空
else if (!wasUncontended) // CAS already known to fail
wasUncontended = true; // Continue after rehash//設(shè)置為未沖突標(biāo)識(shí)，進(jìn)入下一次自旋
else if (U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))//由于指定下標(biāo)位置的cell值不為空，則直接通過cas進(jìn)行原子累加，如果成功，則直接退出
break;
else if (counterCells != as || n >= NCPU)//如果已經(jīng)有其他線程建立了新的counterCells或者CounterCells大于CPU核心數(shù)(很巧妙，線程的并發(fā)數(shù)不會(huì)超過cpu核心數(shù))
collide = false; // At max size or stale //設(shè)置當(dāng)前線程的循環(huán)失敗不進(jìn)行擴(kuò)容
else if (!collide)//恢復(fù)collide狀態(tài)，標(biāo)識(shí)下次循環(huán)會(huì)進(jìn)行擴(kuò)容
collide = true;
else if (cellsBusy == 0 &&//進(jìn)入這個(gè)步驟，說明CounterCell數(shù)組容量不夠，線程競(jìng)爭(zhēng)較大，所以先設(shè)置一個(gè)標(biāo)識(shí)表示為正在擴(kuò)容 else
U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
try {
if (counterCells == as) {// Expand table unless stale
//擴(kuò)容一倍 2變成4，這個(gè)擴(kuò)容比較簡(jiǎn)單
CounterCell[] rs = new CounterCell[n << 1];
for (int i = 0; i < n; ++i)
rs[i] = as[i];
counterCells = rs;
}
} finally {
cellsBusy = 0;//恢復(fù)標(biāo)識(shí)
}
collide = false;
continue; // Retry with expanded table //繼續(xù)下一次自旋
}
h = ThreadLocalRandom.advanceProbe(h);//更新隨機(jī)數(shù)的值
}
else if (cellsBusy == 0 && counterCells == as && //cellsBusy=0表示沒有在做初始化，通過cas更新cellsbusy的值標(biāo)注當(dāng)前線程正在做初始化操作
U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
boolean init = false;
try { // Initialize table
if (counterCells == as) {
CounterCell[] rs = new CounterCell[2];//初始化容量為2
rs[h & 1] = new CounterCell(x);//將x也就是元素的個(gè)數(shù)放在指定的數(shù)組下標(biāo)位置
counterCells = rs;//賦值給counterCells
init = true;//設(shè)置初始化完成標(biāo)識(shí)
}
} finally {
cellsBusy = 0;//恢復(fù)標(biāo)識(shí)
}
if (init)
break;
}
else if (U.compareAndSwapLong(this, BASECOUNT, v = baseCount, v + x))//競(jìng)爭(zhēng)激烈，其它線程占據(jù)cell 數(shù)組，直接累加在base變量中
break; // Fall back on using base
}
}
transfer擴(kuò)容private final void transfer(Node[] tab, Node[] nextTab) {
int n = tab.length, stride;
//將 (n>>>3相當(dāng)于 n/8) 然后除以 CPU核心數(shù)。如果得到的結(jié)果小于 16，那么就使用 16
// 這里的目的是讓每個(gè) CPU 處理的桶一樣多，避免出現(xiàn)轉(zhuǎn)移任務(wù)不均勻的現(xiàn)象，如果桶較少的話，默認(rèn)一個(gè) CPU(一個(gè)線程)處理 16 個(gè)桶，也就是長(zhǎng)度為16的時(shí)候，擴(kuò)容的時(shí)候只會(huì)有一個(gè)線程來擴(kuò)容
if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
stride = MIN_TRANSFER_STRIDE; // subdivide range
//nextTab未初始化，nextTab是用來擴(kuò)容的node數(shù)組
if (nextTab == null) { // initiating
try {
@SuppressWarnings("unchecked")
//新建一個(gè)n<<1原始table大小的nextTab,也就是32
Node[] nt = (Node[])new Node,?>[n << 1];
nextTab = nt;//賦值給nextTab
} catch (Throwable ex) { // try to cope with OOME
sizeCtl = Integer.MAX_VALUE;//擴(kuò)容失敗，sizeCtl使用int的最大值
return;
}
nextTable = nextTab;//更新成員變量
transferIndex = n;//更新轉(zhuǎn)移下標(biāo)，表示轉(zhuǎn)移時(shí)的下標(biāo)
}
int nextn = nextTab.length;//新的tab的長(zhǎng)度
// 創(chuàng)建一個(gè) fwd 節(jié)點(diǎn)，表示一個(gè)正在被遷移的Node，并且它的hash值為-1(MOVED)，
// 也就是前面我們?cè)谥vputval方法的時(shí)候，會(huì)有一個(gè)判斷MOVED的邏輯。
// 它的作用是用來占位，表示原數(shù)組中位置i處的節(jié)點(diǎn)完成遷移以后，
// 就會(huì)在i位置設(shè)置一個(gè)fwd來告訴其他線程這個(gè)位置已經(jīng)處理過了，具體后續(xù)還會(huì)在講
ForwardingNode fwd = new ForwardingNode(nextTab);
// 首次推進(jìn)為 true，如果等于 true，說明需要再次推進(jìn)一個(gè)下標(biāo)(i--)，反之，如果是 false，那么就不能推進(jìn)下標(biāo)，需要將當(dāng)前的下標(biāo)處理完畢才能繼續(xù)推進(jìn)
boolean advance = true;
//判斷是否已經(jīng)擴(kuò)容完成，完成就return，退出循環(huán)
boolean finishing = false; // to ensure sweep before committing nextTab
//通過for自循環(huán)處理每個(gè)槽位中的鏈表元素，默認(rèn)advace為真，通過CAS設(shè)置transferIndex屬性值，
// 并初始化i和bound值，i指當(dāng)前處理的槽位序號(hào)，bound指需要處理的槽位邊界，先處理槽位15的節(jié)點(diǎn)；
for (int i = 0, bound = 0;;) {
// 這個(gè)循環(huán)使用CAS不斷嘗試為當(dāng)前線程分配任務(wù)
// 直到分配成功或任務(wù)隊(duì)列已經(jīng)被全部分配完畢
// 如果當(dāng)前線程已經(jīng)被分配過bucket區(qū)域
// 那么會(huì)通過--i指向下一個(gè)待處理bucket然后退出該循環(huán)
Node f; int fh;
while (advance) {
int nextIndex, nextBound;
//--i表示下一個(gè)待處理的bucket，如果它>=bound,表示當(dāng)前線程已經(jīng)分配過bucket區(qū)域
if (--i >= bound || finishing)
advance = false;
else if ((nextIndex = transferIndex) <= 0) {//表示所有bucket已經(jīng)被分配完畢
i = -1;
advance = false;
}
//通過cas來修改TRANSFERINDEX,為當(dāng)前線程分配任務(wù)，處理的節(jié)點(diǎn)區(qū)間為(nextBound,nextIndex)->(0,15)
else if (U.compareAndSwapInt
(this, TRANSFERINDEX, nextIndex,
nextBound = (nextIndex > stride ?
nextIndex - stride : 0))) {
bound = nextBound;
i = nextIndex - 1;
advance = false;
}
}
//i<0說明已經(jīng)遍歷完舊的數(shù)組，也就是當(dāng)前線程已經(jīng)處理完所有負(fù)責(zé)的bucket
if (i < 0 || i >= n || i + n >= nextn) {
int sc;
if (finishing) {//如果完成了擴(kuò)容
nextTable = null;//刪除成員變量
table = nextTab;//更新table數(shù)組
sizeCtl = (n << 1) - (n >>> 1);//更新閾值(32*0.75=24)
return;
}
// sizeCtl 在遷移前會(huì)設(shè)置為 (rs << RESIZE_STAMP_SHIFT) + 2
// 然后，每增加一個(gè)線程參與遷移就會(huì)將 sizeCtl 加 1， // 這里使用 CAS 操作對(duì) sizeCtl 的低16位進(jìn)行減 1，代表做完了屬于自己的任務(wù)
if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
//第一個(gè)擴(kuò)容的線程，執(zhí)行transfer方法之前，會(huì)設(shè)置 sizeCtl = (resizeStamp(n) << RESIZE_STAMP_SHIFT) + 2)
// 后續(xù)幫其擴(kuò)容的線程，執(zhí)行transfer方法之前，會(huì)設(shè)置 sizeCtl = sizeCtl+1 每一個(gè)退出transfer的方法的線程，退出之前，
// 會(huì)設(shè)置 sizeCtl = sizeCtl-1 那么最后一個(gè)線程退出時(shí)：必然有 sc == (resizeStamp(n) << RESIZE_STAMP_SHIFT) + 2)，
// 即 (sc - 2) == resizeStamp(n) << RESIZE_STAMP_SHIFT // 如果 sc - 2 不等于標(biāo)識(shí)符左移 16 位。如果他們相等了，
// 說明沒有線程在幫助他們擴(kuò)容了。也就是說，擴(kuò)容結(jié)束了。
if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
return;
// 如果相等，擴(kuò)容結(jié)束了，更新 finising 變量
finishing = advance = true;
// 再次循環(huán)檢查一下整張表
i = n; // recheck before commit
}
}
// 如果位置 i 處是空的，沒有任何節(jié)點(diǎn)，那么放入剛剛初始化的 ForwardingNode ”空節(jié)點(diǎn)“
else if ((f = tabAt(tab, i)) == null)
advance = casTabAt(tab, i, null, fwd);
//表示該位置已經(jīng)完成了遷移，也就是如果線程A已經(jīng)處理過這個(gè)節(jié)點(diǎn)，那么線程B處理這個(gè)節(jié)點(diǎn)時(shí)，hash值一定為MOVED
else if ((fh = f.hash) == MOVED)
advance = true; // already processed
else {
synchronized (f) {//對(duì)數(shù)組該節(jié)點(diǎn)位置加鎖，開始處理數(shù)組該位置的遷移工作
if (tabAt(tab, i) == f) {
Node ln, hn;///ln 表示低位， hn 表示高位 接下來這段代碼的作用 是把鏈表拆分成兩部分， 0 在低位， 1 在高位
if (fh >= 0) {
int runBit = fh & n;
Node lastRun = f;
//遍歷當(dāng)前bucket的鏈表，目的是盡量重用Node鏈表尾部的一部分
for (Node p = f.next; p != null; p = p.next) {
int b = p.hash & n;
if (b != runBit) {
runBit = b;
lastRun = p;
}
}
if (runBit == 0) {//如果最后更新的runBit是0，設(shè)置低位節(jié)點(diǎn)
ln = lastRun;
hn = null;
}
else {//否則，設(shè)置高位節(jié)點(diǎn)
hn = lastRun;
ln = null;
}
//構(gòu)造高位以及低位的鏈表
for (Node 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(ph, pk, pv, ln);
else
hn = new Node(ph, pk, pv, hn);
}
setTabAt(nextTab, i, ln);//將低位的鏈表放在 i 位置也就是不動(dòng)
setTabAt(nextTab, i + n, hn);//將高位鏈表放在 i+n 位置
setTabAt(tab, i, fwd);// 把舊 table 的 hash 桶中放置轉(zhuǎn)發(fā)節(jié)點(diǎn)，表明此 hash 桶已經(jīng)被處理
advance = true;
}
else if (f instanceof TreeBin) { //紅黑 樹的擴(kuò)容部分
TreeBin t = (TreeBin)f;
TreeNode lo = null, loTail = null;
TreeNode hi = null, hiTail = null;
int lc = 0, hc = 0;
for (Node e = t.first; e != null; e = e.next) {
int h = e.hash;
TreeNode p = new TreeNode
(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(lo) : t;
hn = (hc <= UNTREEIFY_THRESHOLD) ? untreeify(hi) :
(lc != 0) ? new TreeBin(hi) : t;
setTabAt(nextTab, i, ln);
setTabAt(nextTab, i + n, hn);
setTabAt(tab, i, fwd);
advance = true;
}
}
}
}
}
}
resizeStampstatic final int resizeStamp(int n) { return Integer.numberOfLeadingZeros(n) | (1 << (RESIZE_STAMP_BITS - 1)); }
helpTransferprivate final void tryPresize(int size) {
//對(duì)size進(jìn)行修復(fù),主要目的是防止傳入的值不是一個(gè)2次冪的整數(shù)，然后通過tableSizeFor來講入?yún)⑥D(zhuǎn)化為離該整數(shù)最近的2次冪
int c = (size >= (MAXIMUM_CAPACITY >>> 1)) ? MAXIMUM_CAPACITY :
tableSizeFor(size + (size >>> 1) + 1);
int sc;
while ((sc = sizeCtl) >= 0) {
Node[] tab = table; int n;
//下面這段代碼和initTable是一樣的，如果table沒有初始化，則開始初始化
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[] nt = (Node[])new Node,?>[n];
table = nt;
sc = n - (n >>> 2);
}
} finally {
sizeCtl = sc;
}
}
}
else if (c <= sc || n >= MAXIMUM_CAPACITY)
break;
else if (tab == table) { //這段代碼和addCount后部分代碼是一樣的，做輔助擴(kuò)容操作
int rs = resizeStamp(n);
if (sc < 0) {
Node[] 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);
}
}
}
treeifyBinprivate final void treeifyBin(Node[] tab, int index) {
Node b; int n, sc;
if (tab != null) {
if ((n = tab.length) < MIN_TREEIFY_CAPACITY)//tab的長(zhǎng)度是不是小于64，如果是，則執(zhí)行擴(kuò)容
tryPresize(n << 1);
else if ((b = tabAt(tab, index)) != null && b.hash >= 0) {//否則，將當(dāng)前鏈表轉(zhuǎn)化為紅黑樹結(jié)構(gòu)存儲(chǔ)
synchronized (b) { // 將鏈表轉(zhuǎn)換成紅黑樹
if (tabAt(tab, index) == b) {
TreeNode hd = null, tl = null;
for (Node e = b; e != null; e = e.next) {
TreeNode p =
new TreeNode(e.hash, e.key, e.val,
null, null);
if ((p.prev = tl) == null)
hd = p;
else
tl.next = p;
tl = p;
}
setTabAt(tab, index, new TreeBin(hd));
}
}
}
}
}
tryPresizeprivate final void tryPresize(int size) {
//對(duì)size進(jìn)行修復(fù),主要目的是防止傳入的值不是一個(gè)2次冪的整數(shù)，然后通過tableSizeFor來講入?yún)⑥D(zhuǎn)化為離該整數(shù)最近的2次冪
int c = (size >= (MAXIMUM_CAPACITY >>> 1)) ? MAXIMUM_CAPACITY :
tableSizeFor(size + (size >>> 1) + 1);
int sc;
while ((sc = sizeCtl) >= 0) {
Node[] tab = table; int n;
//下面這段代碼和initTable是一樣的，如果table沒有初始化，則開始初始化
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[] nt = (Node[])new Node,?>[n];
table = nt;
sc = n - (n >>> 2);
}
} finally {
sizeCtl = sc;
}
}
}
else if (c <= sc || n >= MAXIMUM_CAPACITY)
break;
else if (tab == table) { //這段代碼和addCount后部分代碼是一樣的，做輔助擴(kuò)容操作
int rs = resizeStamp(n);
if (sc < 0) {
Node[] 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);
}
}
}查看原文
總結(jié)
以上是生活随笔為你收集整理的mysql http_put_洪永佳 - SegmentFault 思否的全部?jī)?nèi)容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： Docker RabbitMQ日志映射
- 下一篇： SQL 子查询