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());//計算 hash 值
　　int binCount = 0;//用來記錄鏈表的長度
　　for (Node<K,V>[] tab = table;;) {//這里其實就是自旋操作，當出現(xiàn)線程競爭時不斷自旋
　　　　Node<K,V> f; int n, i, fh;
　　　　if (tab == null || (n = tab.length) == 0)//如果數(shù)組為空，則進行數(shù)組初始 化
　　　　　　tab = initTable();//初始化數(shù)組
　　　　　　//通過 hash 值對應的數(shù)組下標得到第一個節(jié)點; 以 volatile 讀的方式來讀取 table 數(shù)
　　　　　　//組中的元素，保證每次拿到的數(shù)據(jù)都是最新的
　　　　　　//(Node<K,V>)U.getObjectVolatile(tab, ((long)i << ASHIFT) + ABASE);
　　　　else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
　　　　　　 //如果該下標返回的節(jié)點為空，則直接通過 cas 將新的值封裝成 node 插入即可；
　　　　　　//如果 cas 失敗，說明存在競爭，則進入下一次循環(huán)
　　　　　　if (casTabAt(tab, i, null,new Node<K,V>(hash, key, value, null)))
　　　　　　　　break; // no lock when adding to empty bin
　　　　　　}　　　　}
    .......
}

private final Node<K,V>[] initTable() {
    Node<K,V>[] tab; int sc;
    while ((tab = table) == null || tab.length == 0) {
      if ((sc = sizeCtl) < 0)//被其他線程搶占了初始化的操作,則直接讓出自己的 CPU 時間片
        Thread.yield(); // lost initialization race; just spin
      //通過 cas 操作，將 sizeCtl 替換為-1，標識當前線程搶占到了初始化資格
      //第一次進來初始化一定走這里
      else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
        try {
          if ((tab = table) == null || tab.length == 0) {
            //默認初始容量為 16
            int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
            @SuppressWarnings("unchecked")
            //初始化數(shù)組，長度為 16，或者初始化在構造 ConcurrentHashMap 的時候傳入的長度
            Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
            table = tab = nt;//將這個數(shù)組賦值給 table
            //計算下次擴容的大小，實際就是當前容量的 0.75倍，這里使用了右移來計算
            //sc =12
            sc = n - (n >>> 2);
          }
        } finally {
          //設置 sizeCtl 為 sc, 如果默認是 16 的話，那么這個時候sc=16*0.75=12
          sizeCtl = sc;
        }
        break;
      }
    }
    return tab;
}

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);
}

........

　　//將當前 ConcurrentHashMap 的元素數(shù)量加 1，有可能觸發(fā) transfer 操作(擴容)
　　addCount(1L, binCount);
　　return null;
}

private final void addCount(long x, int check) {
    CounterCell[] as; long b, s;
//    判斷 counterCells 是否為空，
//    1. 如果為空，就通過 cas 操作嘗試修改 baseCount 變量，對這個變量進行原子累加操
//    作(做這個操作的意義是：如果在沒有競爭的情況下，仍然采用 baseCount 來記錄元素個 數(shù))
//    2. 如果 cas 失敗說明存在競爭，這個時候不能再采用 baseCount 來累加，而是通過 CounterCell 來記錄
    if ((as = counterCells) != null ||
        !U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {
      CounterCell a; long v; int m;
      boolean uncontended = true;//是否沖突標識，默認為沒有沖突
//      這里有幾個判斷
//      1. 計數(shù)表為空則直接調(diào)用 fullAddCount
//      2. 從計數(shù)表中隨機取出一個數(shù)組的位置為空，直接調(diào)用 fullAddCount
//      3. 通過 CAS 修改 CounterCell 隨機位置的值，如果修改失敗說明出現(xiàn)并發(fā)情況（這里又
//      用到了一種巧妙的方法），調(diào)用 fullAndCount
//      Random 在線程并發(fā)的時候會有性能問題以及可能會產(chǎn)生相同的隨機
//      數(shù) ,ThreadLocalRandom.getProbe 可以解決這個問題，并且性能要比 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);//執(zhí)行 fullAddCount 方法
        return;
      }
      if (check <= 1)//鏈表長度小于等于 1，不需要考慮擴容
        return;
      s = sumCount();//統(tǒng)計 ConcurrentHashMap 元素個數(shù)
    }
  .......
}

private transient volatile int cellsBusy;// 標識當前 cell 數(shù)組是否在初始化或擴容中的CAS 標志位
/**
* Table of counter cells. When non-null, size is a power of 2.
*/
private transient volatile CounterCell[] counterCells;// counterCells 數(shù)組，總數(shù)值的分值分別存在每個 cell 中

@sun.misc.Contended static final class CounterCell {
　　volatile long value;
　　CounterCell(long x) { value = x; }
}
//看到這段代碼就能夠明白了，CounterCell 數(shù)組的每個元素，都存儲一個元素個數(shù)，而實際我們調(diào)用size 方法就是通過這個循環(huán)累加來得到的
//又是一個設計精華，大家可以借鑒； 有了這個前提，再會過去看 addCount 這個方法，就容易理解一些了
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;
}

private final void fullAddCount(long x, boolean wasUncontended) {
    int h;
    //獲取當前線程的 probe 的值，如果值為 0，則初始化當前線程的 probe 的值,probe 就是隨機數(shù)
    if ((h = ThreadLocalRandom.getProbe()) == 0) {
      ThreadLocalRandom.localInit();   // force initialization
      h = ThreadLocalRandom.getProbe();
      wasUncontended = true; // 由于重新生成了 probe，未沖突標志位設置為 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) {
        // 通過該值與當前線程 probe 求與，獲得cells 的下標元素，和 hash 表獲取索引是一樣的
        if ((a = as[(n - 1) & h]) == null) {
          //cellsBusy=0 表示 counterCells 不在初始化或者擴容狀態(tài)下
          if (cellsBusy == 0) {// Try to attach new Cell
            //構造一個 CounterCell 的值，傳入元素個數(shù)
            CounterCell r = new CounterCell(x); // Optimistic create
            //通過 cas 設置 cellsBusy 標識，防止其他線程來對 counterCells 并發(fā)處理
            if (cellsBusy == 0 &&
                U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
              boolean created = false;
              try {        // Recheck under lock
                CounterCell[] rs; int m, j;
                //將初始化的 r 對象的元素個數(shù)放在對應下標的位置
                if ((rs = counterCells) != null &&
                    (m = rs.length) > 0 &&
                    rs[j = (m - 1) & h] == null) {
                  rs[j] = r;
                  created = true;
                }
              } finally {//恢復標志位
                cellsBusy = 0;
              }
              if (created)//創(chuàng)建成功，退出循環(huán)
                break;
              //說明指定 cells 下標位置的數(shù)據(jù)不為空，則進行下一次循環(huán)
              continue;      // Slot is now non-empty
            }
          }
          collide = false;
        }
        //說明在 addCount 方法中 cas 失敗了，并且獲取 probe 的值不為空
        else if (!wasUncontended)    // CAS already known to fail
          // 設置為未沖突標識，進入下一次自旋
          wasUncontended = true;   // Continue after rehash
        // 由于指定下標位置的 cell 值不為空，則直接通過 cas 進行原子累加，如果成功，則直接退出
        else if (U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))
          break;
        // 如果已經(jīng)有其他線程建立了新的 counterCells
        // 或者 CounterCells 大于 CPU 核心數(shù)（很巧妙，線程的并發(fā)數(shù)不會超過 cpu 核心數(shù)）
        else if (counterCells != as || n >= NCPU)
          //設置當前線程的循環(huán)失敗不進行擴容
          collide = false;      // At max size or stale
        else if (!collide)//恢復 collide 狀態(tài)，標識下次循環(huán)會進行擴容
          collide = true;
        //進入這個步驟，說明 CounterCell 數(shù)組容量不夠，線程競爭較大，所以先設置一個標識表示為正在擴容
        else if (cellsBusy == 0 &&
            U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
          try {
            if (counterCells == as) {// Expand table unless stale
              // 擴容一倍 2 變成 4 ，這個擴容比較簡單
              CounterCell[] rs = new CounterCell[n << 1];
              for (int i = 0; i < n; ++i)
                rs[i] = as[i];
              counterCells = rs;
            }
          } finally {
            cellsBusy = 0;//恢復標識
          }
          collide = false;
          // 繼續(xù)下一次自旋
          continue;          // Retry with expanded table
        }//更新隨機數(shù)的值
        h = ThreadLocalRandom.advanceProbe(h);
      }
      //cellsBusy=0 表示沒有在做初始化，通過 cas 更新 cellsbusy 的值標注當前線程正在做初始化操作
      else if (cellsBusy == 0 && counterCells == as &&
          U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
        boolean init = false;
        try {              // Initialize table
          if (counterCells == as) { //初始化容量為 2
            CounterCell[] rs = new CounterCell[2];
            //將 x 也就是元素的個數(shù)放在指定的數(shù)組下標位置
            rs[h & 1] = new CounterCell(x);
            counterCells = rs;//賦值給 counterCells
            init = true;//設置初始化完成標識
          }
        } finally {//恢復標識
          cellsBusy = 0;
        }
        if (init)
          break;
      }
      //競爭激烈，其它線程占據(jù) cell 數(shù)組，直接累加在 base 變量中
      else if (U.compareAndSwapLong(this, BASECOUNT, v = baseCount, v + x))
        break;             // Fall back on using base
    }
  }

private final void addCount(long x, int check) {
　　　　　........if (check >= 0) {//如果 binCount>=0，標識需要檢查擴容
      Node<K,V>[] tab, nt; int n, sc;
      //s 標識集合大小，如果集合大小大于或等于擴容閾值（默認值的 0.75）
      //并且 table 不為空并且 table 的長度小于最大容量
      while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&
          (n = tab.length) < MAXIMUM_CAPACITY) {
        //這里是生成一個唯一的擴容戳，這個是干嘛用的呢？
        int rs = resizeStamp(n);
        if (sc < 0) {//sc<0，也就是 sizeCtl<0，說明已經(jīng)有別的線程正在擴容了
          // 這 5 個條件只要有一個條件為 true，說明當前線程不能幫助進行此次的擴容，直接跳出循環(huán)
          // sc >>> RESIZE_STAMP_SHIFT!=rs 表示比較高 RESIZE_STAMP_BITS 位生成戳和 rs 是否相等，相同
          // sc=rs+1 表示擴容結束
          // sc==rs+MAX_RESIZERS 表示幫助線程線程已經(jīng)達到最大值了
          // nt=nextTable -> 表示擴容已經(jīng)結束
          // transferIndex<=0 表示所有的 transfer 任務都被領取完了，
          // 沒有剩余的hash 桶來給自己自己好這個線程來做 transfer
          if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
              sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
              transferIndex <= 0)
            break;
          //當前線程嘗試幫助此次擴容，如果成功，則調(diào)用 transfer
          if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
            transfer(tab, nt);
        }
        // 如果當前沒有在擴容，那么 rs 肯定是一個正數(shù)，
        // 通過 rs<<RESIZE_STAMP_SHIFT 將 sc 設置為一個負數(shù)，+2 表示有一個線程在執(zhí)行擴容
        else if (U.compareAndSwapInt(this, SIZECTL, sc,
            (rs << RESIZE_STAMP_SHIFT) + 2))
          transfer(tab, null);
        s = sumCount();// 重新計數(shù)，判斷是否需要開啟下一輪擴容
      }
    }
  }

static final int resizeStamp(int n) {
　　return Integer.numberOfLeadingZeros(n) | (1 << (RESIZE_STAMP_BITS - 1));
}

private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
    int n = tab.length, stride;
    //將 (n>>>3 相當于 n/8) 然后除以 CPU 核心數(shù)。如果得到的結果小于 16，那么就使用 16
    // 這里的目的是讓每個 CPU 處理的桶一樣多，避免出現(xiàn)轉移任務不均勻的現(xiàn)象，如果桶較少的話，
    // 默認一個 CPU（一個線程）處理 16 個桶，也就是長度為 16 的時候，擴容的時候只會有一個線程來擴容
    if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
      stride = MIN_TRANSFER_STRIDE; // subdivide range
    //nextTab 未初始化， nextTab 是用來擴容的 node 數(shù)組
    if (nextTab == null) {      // initiating
      try {
        @SuppressWarnings("unchecked")
        //新建一個 n<<1 原始 table 大小的 nextTab,也就是 32
        Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1];
        nextTab = nt;//賦值給 nextTab
      } catch (Throwable ex) {   // try to cope with OOME
        //擴容失敗，sizeCtl 使用 int 的最大值
        sizeCtl = Integer.MAX_VALUE;
        return;
      }
      nextTable = nextTab;//更新成員變量
      transferIndex = n;//更新轉移下標，表示轉移時的下標
    }//新的 tab 的長度
    int nextn = nextTab.length;
    // 創(chuàng)建一個 fwd 節(jié)點，表示一個正在被遷移的 Node，并且它的 hash 值為-1(MOVED)，也
    // 就是前面我們在講 putval 方法的時候，會有一個判斷 MOVED 的邏輯。它的作用是用來占位，表示
    // 原數(shù)組中位置 i 處的節(jié)點完成遷移以后，就會在 i 位置設置一個 fwd 來告訴其他線程這個位置已經(jīng)處理過了，
    ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
    // 首次推進為 true，如果等于 true，說明需要再次推進一個下標（i--），反之，
    // 如果是false，那么就不能推進下標，需要將當前的下標處理完畢才能繼續(xù)推進
    boolean advance = true;
    //判斷是否已經(jīng)擴容完成，完成就 return，退出循環(huán)
    boolean finishing = false; // to ensure sweep before committing nextTab
    // 通過 for 自循環(huán)處理每個槽位中的鏈表元素，默認 advace 為真，通過 CAS 設置
    // transferIndex 屬性值，并初始化 i 和 bound 值， i 指當前處理的槽位序號， bound 指需要處理
    // 的槽位邊界，先處理槽位 15 的節(jié)點；
    for (int i = 0, bound = 0;;) {
      // 這個循環(huán)使用 CAS 不斷嘗試為當前線程分配任務
      // 直到分配成功或任務隊列已經(jīng)被全部分配完畢
      // 如果當前線程已經(jīng)被分配過 bucket 區(qū)域
      // 那么會通過--i 指向下一個待處理 bucket 然后退出該循環(huán)
      Node<K,V> f; int fh;
      while (advance) {
        int nextIndex, nextBound;
        //--i 表示下一個待處理的 bucket，如果它>=bound,表示當前線程已經(jīng)分配過bucket 區(qū)域
        if (--i >= bound || finishing)
          advance = false;
        else if ((nextIndex = transferIndex) <= 0) {//表示所有 bucket 已經(jīng)被分配完畢
          i = -1;
          advance = false;
        }
        //通過 cas 來修改 TRANSFERINDEX,為當前線程分配任務，處理的節(jié)點區(qū)間為(nextBound,nextIndex)->(0,15)
        else if (U.compareAndSwapInt
            (this, TRANSFERINDEX, nextIndex,
                nextBound = (nextIndex > stride ?
                    nextIndex - stride : 0))) {
          bound = nextBound;//0
          i = nextIndex - 1;//15
          advance = false;
        }
      }
      //i<0 說明已經(jīng)遍歷完舊的數(shù)組，也就是當前線程已經(jīng)處理完所有負責的 bucket
      if (i < 0 || i >= n || i + n >= nextn) {
        int sc;
        if (finishing) {//如果完成了擴容
          nextTable = null;//刪除成員變量
          table = nextTab;//更新 table 數(shù)組
          sizeCtl = (n << 1) - (n >>> 1);//更新閾值(32*0.75=24)
          return;
        }
        // sizeCtl 在遷移前會設置為 (rs << RESIZE_STAMP_SHIFT) + 2
        // 然后，每增加一個線程參與遷移就會將 sizeCtl 加 1，
        // 這里使用 CAS 操作對 sizeCtl 的低 16 位進行減 1，代表做完了屬于自己的任務
        // if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
        // 第一個擴容的線程，執(zhí)行 transfer 方法之前，會設置 sizeCtl = (resizeStamp(n) << RESIZE_STAMP_SHIFT) + 2)
        // 后續(xù)幫其擴容的線程，執(zhí)行 transfer 方法之前，會設置 sizeCtl = sizeCtl+1
        // 每一個退出 transfer 的方法的線程，退出之前，會設置 sizeCtl = sizeCtl-1 那么最后一個線程退出時：必然有
        // sc == (resizeStamp(n) << RESIZE_STAMP_SHIFT) + 2)，即 (sc - 2) == resizeStamp(n) << RESIZE_STAMP_SHIFT
        // 如果 sc - 2 不等于標識符左移 16 位。如果他們相等了，說明沒有線程在幫助他們擴容了。也就是說，擴容結束了。
        if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
          if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
            return;
          // 如果相等，擴容結束了，更新 finising 變量
          finishing = advance = true;
          // 再次循環(huán)檢查一下整張表
          i = n; // recheck before commit
        }
      }// 如果位置 i 處是空的，沒有任何節(jié)點，那么放入剛剛初始化的 ForwardingNode ”空節(jié)點“
      else if ((f = tabAt(tab, i)) == null)
        advance = casTabAt(tab, i, null, fwd);
      //表示該位置已經(jīng)完成了遷移，也就是如果線程 A 已經(jīng)處理過這個節(jié)點，那么線程 B 處理這個節(jié)點時，hash 值一定為 MOVED
      else if ((fh = f.hash) == MOVED)
        advance = true; // already processed
　　　　......
}

if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
　　if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)

for (Node<K,V> p = f.next; p != null; p = p.next) {
  int b = p.hash & n;
  if (b != runBit) {
    runBit = b;
    lastRun = p;
  }
}

setTabAt(nextTab, i, ln);
setTabAt(nextTab, i + n, hn);
setTabAt(tab, i, fwd);

else {
        synchronized (f) {//對數(shù)組該節(jié)點位置加鎖，開始處理數(shù)組該位置的遷移工作
          if (tabAt(tab, i) == f) {//再做一次校驗
            //ln 表示低位， hn 表示高位;接下來這段代碼的作用是把鏈表拆分成兩部分，0 在低位，1 在高位
            Node<K,V> ln, hn;
            if (fh >= 0) {
              //下面部分代碼原理在上面分析了
              int runBit = fh & n;
              Node<K,V> lastRun = f;
              //遍歷當前 bucket 的鏈表，目的是盡量重用 Node 鏈表尾部的一部分
              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，設置低位節(jié)點
              if (runBit == 0) {
                ln = lastRun;
                hn = null;
              }//否則，設置高位節(jié)點
              else {
                hn = lastRun;
                ln = null;
              }//構造高位以及低位的鏈表
              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);
              }
              //將低位的鏈表放在 i 位置也就是不動
              setTabAt(nextTab, i, ln);
              //將高位鏈表放在 i+n 位置
              setTabAt(nextTab, i + n, hn);
              // 把舊 table 的 hash 桶中放置轉發(fā)節(jié)點，表明此 hash 桶已經(jīng)被處理
              setTabAt(tab, i, fwd);
              advance = true;
            }//f 是紅黑樹的根節(jié)點
            else if (f instanceof TreeBin) {
              TreeBin<K,V> t = (TreeBin<K,V>)f;
              //創(chuàng)建低位的樹節(jié)點
              TreeNode<K,V> lo = null, loTail = null;
              //創(chuàng)建高位的樹節(jié)點
              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;
                }
              }
              //判斷是否長度< 6 轉成鏈表
              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;
            }
          }
        }
      }

//i<0 說明已經(jīng)遍歷完舊的數(shù)組，也就是當前線程已經(jīng)處理完所有負責的 bucket
      if (i < 0 || i >= n || i + n >= nextn) {
        int sc;
        if (finishing) {//如果完成了擴容
          nextTable = null;//刪除成員變量
          table = nextTab;//更新 table 數(shù)組
          sizeCtl = (n << 1) - (n >>> 1);//更新閾值(32*0.75=24)
          return;
        }
        // sizeCtl 在遷移前會設置為 (rs << RESIZE_STAMP_SHIFT) + 2
        // 然后，每增加一個線程參與遷移就會將 sizeCtl 加 1，
        // 這里使用 CAS 操作對 sizeCtl 的低 16 位進行減 1，代表做完了屬于自己的任務
        if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
          // 第一個擴容的線程，執(zhí)行 transfer 方法之前，會設置 sizeCtl = (resizeStamp(n) << RESIZE_STAMP_SHIFT) + 2)
          // 后續(xù)幫其擴容的線程，執(zhí)行 transfer 方法之前，會設置 sizeCtl = sizeCtl+1
          // 每一個退出 transfer 的方法的線程，退出之前，會設置 sizeCtl = sizeCtl-1 那么最后一個線程退出時：必然有
          // sc == (resizeStamp(n) << RESIZE_STAMP_SHIFT) + 2)，即 (sc - 2) == resizeStamp(n) << RESIZE_STAMP_SHIFT
          // 如果 sc - 2 不等于標識符左移 16 位。如果他們相等了，說明沒有線程在幫助他們擴容了。也就是說，擴容結束了。
          if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
            return;
          // 如果相等，擴容結束了，更新 finising 變量
          finishing = advance = true;
          // 再次循環(huán)檢查一下整張表
          i = n; // recheck before commit
        }
      }

else if ((fh = f.hash) == MOVED)
  tab = helpTransfer(tab, f);

final Node<K,V>[] helpTransfer(Node<K,V>[] tab, Node<K,V> f) {
    Node<K,V>[] nextTab; int sc;
    // 判斷此時是否仍然在執(zhí)行擴容,nextTab=null 的時候說明擴容已經(jīng)結束了
    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) {//說明擴容還未完成的情況下不斷循環(huán)來嘗試將當前線程加入到擴容操作中
        // 下面部分的整個代碼表示擴容結束，直接退出循環(huán)
        // transferIndex<=0 表示所有的 Node 都已經(jīng)分配了線程
        // sc=rs+MAX_RESIZERS 表示擴容線程數(shù)達到最大擴容線程數(shù)
        // sc >>> RESIZE_STAMP_SHIFT !=rs， 如果在同一輪擴容中，
        // 那么 sc 無符號右移比較高位和 rs 的值，那么應該是相等的。如果不相等，說明擴容結束了
        //sc==rs+1 表示擴容結束
        if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
            sc == rs + MAX_RESIZERS || transferIndex <= 0)
          break;
        //在低 16 位上增加擴容線程數(shù)
        if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)) {
          transfer(tab, nextTab);//幫助擴容
          break;
        }
      }
      return nextTab;//返回新的數(shù)組
    }
    return table;
  }

else {//進入到這個分支，說明 f 是當前 nodes 數(shù)組對應位置節(jié)點的頭節(jié)點，并且不為空
        V oldVal = null;
        synchronized (f) { //給對應的頭結點加鎖
          if (tabAt(tab, i) == f) {//再次判斷對應下標位置是否為 f 節(jié)點
            if (fh >= 0) {//頭結點的 hash 值大于 0，說明是鏈表
              binCount = 1;//用來記錄鏈表的長度
              for (Node<K,V> e = f;; ++binCount) {//遍歷鏈表
                K ek;
                //如果發(fā)現(xiàn)相同的 key，則判斷是否需要進行值的覆蓋
                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;
                }
              }
            }
            //如果當前的 f 節(jié)點是一顆紅黑樹
            else if (f instanceof TreeBin) {
              Node<K,V> p;
              binCount = 2;
              //則調(diào)用紅黑樹的插入方法插入新的值
              if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
                  value)) != null) {
                oldVal = p.val;
                //同樣，如果值已經(jīng)存在，則直接替換
                if (!onlyIfAbsent)
                  p.val = value;
              }
            }
          }
        }//說明上面在做鏈表操作
        if (binCount != 0) {
          if (binCount >= TREEIFY_THRESHOLD)
            //如果鏈表長度已經(jīng)達到臨界值 8 就需要把鏈表轉換為樹結構
            treeifyBin(tab, i);
          if (oldVal != null)
            //如果 val 是被替換的，則返回替換之前的值
            return oldVal;
          break;
        }
      }

private final void treeifyBin(Node<K,V>[] tab, int index) {
    Node<K,V> b; int n, sc;
    if (tab != null) {//tab 的長度是不是小于 64，如果是，則執(zhí)行擴容
      if ((n = tab.length) < MIN_TREEIFY_CAPACITY)
        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;
            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;
            }
            setTabAt(tab, index, new TreeBin<K,V>(hd));
          }
        }
      }
    }
  }

private final void tryPresize(int size) {
    //對 size 進行修復,主要目的是防止傳入的值不是一個 2 次冪的整數(shù)，
    // 然后通過tableSizeFor 來將入?yún)⑥D化為離該整數(shù)最近的 2 次冪
    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;
      //下面這段代碼和 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<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) {//這段代碼和 addCount 后部分代碼是一樣的，做輔助擴容操作
        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);
      }
    }
  }