Java8 ConcurrentHashMap詳解-從源碼分析

前言

前段時間自己一直在面試，很多面試官都會問到一個問題就是讓我介紹ConcurrentHashMap是如何實現多線程操作的，以及與HashTable有什麼區別？我自己雖然瞭解了一些這類的知識，但是也只是皮毛，沒有深入瞭解過其中的實現過程，更沒有從源碼分析過是如何實現的，所以今天有空把以前自己缺失的知識補充一下，擴展自己的知識嘛！
畢竟走在學習路上的程序員，怎麼能不學習，當然了也要一直膜拜大佬！

以下文章的內容來源：https://blog.csdn.net/sihai12345/article/details/79383766

Java8中ConcurrentHashMap的結構：

從這個圖中也能看出來ConcurrentHashMap是由K，V形式進行存儲的，並且V的存儲結構有鏈表、紅黑樹兩種形式！

1、初始化

// 這構造函數裏，什麼都不幹
public ConcurrentHashMap() {
}

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

ConcurrentHashMap的構造函數中通過提供的一個初始容量計算出了sizeCtl，sizeCtl = (1.5 * initialCapacity + 1)。
sizeCtl有如下含義 ：

• 負數代表正在進行初始化或擴容操作
• -1代表正在初始化
• -N 表示有N-1個線程正在進行擴容操作
• 正數或0代表hash表還沒有被初始化，這個數值表示初始化或下一次進行擴容的大小，這一點類似於擴容閾值的概念。還後面可以看到，它的值始終是當前ConcurrentHashMap容量的0.75倍，這與loadfactor是對應的。

摘自：https://blog.csdn.net/weixin_28760063/article/details/81211988

2、put方法分析

public V put(K key, V value) {
    return putVal(key, value, false);
}

final V putVal(K key, V value, boolean onlyIfAbsent) {
    if (key == null || value == null) throw new NullPointerException();
    // 得到 hash 值
    int hash = spread(key.hashCode());
    // 用於記錄相應鏈表的長度
    int binCount = 0;
    for (Node<K,V>[] tab = table;;) {
        Node<K,V> f; int n, i, fh;
        // 如果數組"空"，進行數組初始化
        if (tab == null || (n = tab.length) == 0)
            // 初始化數組，後面會詳細介紹
            tab = initTable();

        // 找該 hash 值對應的數組下標，得到第一個節點 f
        else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
            // 如果數組該位置爲空，
            //    用一次 CAS 操作將這個新值放入其中即可，這個 put 操作差不多就結束了，可以拉到最後面了
            //          如果 CAS 失敗，那就是有併發操作，進到下一個循環就好了
            if (casTabAt(tab, i, null,
                         new Node<K,V>(hash, key, value, null)))
                break;                   // no lock when adding to empty bin
        }
        // hash 居然可以等於 MOVED，這個需要到後面才能看明白，不過從名字上也能猜到，肯定是因爲在擴容
        else if ((fh = f.hash) == MOVED)
            // 幫助數據遷移，這個等到看完數據遷移部分的介紹後，再理解這個就很簡單了
            tab = helpTransfer(tab, f);

        else { // 到這裏就是說，f 是該位置的頭結點，而且不爲空

            V oldVal = null;
            // 獲取數組該位置的頭結點的監視器鎖
            synchronized (f) {
                if (tabAt(tab, i) == f) {
                    if (fh >= 0) { // 頭結點的 hash 值大於 0，說明是鏈表
                        // 用於累加，記錄鏈表的長度
                        binCount = 1;
                        // 遍歷鏈表
                        for (Node<K,V> e = f;; ++binCount) {
                            K ek;
                            // 如果發現了"相等"的 key，判斷是否要進行值覆蓋，然後也就可以 break 了
                            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;
                        }
                    }
                }
            }
            // binCount != 0 說明上面在做鏈表操作
            if (binCount != 0) {
                // 判斷是否要將鏈表轉換爲紅黑樹，臨界值和 HashMap 一樣，也是 8
                if (binCount >= TREEIFY_THRESHOLD)
                    // 這個方法和 HashMap 中稍微有一點點不同，那就是它不是一定會進行紅黑樹轉換，
                    // 如果當前數組的長度小於 64，那麼會選擇進行數組擴容，而不是轉換爲紅黑樹
                    //    具體源碼我們就不看了，擴容部分後面說
                    treeifyBin(tab, i);
                if (oldVal != null)
                    return oldVal;
                break;
            }
        }
    }
    // 
    addCount(1L, binCount);
    return null;
}

在put方法中會根據hash值計算這個新插入的點在table中的位置i，如果i位置是空的，直接放進去，否則進行判斷，如果i位置是樹節點，按照樹的方式插入新的節點，否則把i插入到鏈表的末尾，同時不允許key或value爲null。
對於多線程下的put存在兩種情況：

• 如果一個或多個線程正在對ConcurrentHashMap進行擴容操作，當前線程也要進入擴容的操作中。這個擴容的操作之所以能被檢測到，是因爲transfer方法中在空結點上插入forward節點，如果檢測到需要插入的位置被forward節點佔有，就幫助進行擴容。
• 如果檢測到要插入的節點是非空且不是forward節點，就對這個節點加鎖，這樣就保證了線程安全。儘管這個有一些影響效率，但是還是會比hashTable的synchronized要好得多。

整體流程就是：

1. 首先定義不允許key或value爲null的情況放入
   對於每一個放入的值，首先利用spread方法對key的hashcode進行一次hash計算，由此來確定這個值在table中的位置。如果這個位置是空的，那麼直接放入，而且不需要加鎖操作。
2. 如果這個位置存在結點，說明發生了hash碰撞，首先判斷這個節點的類型。如果是鏈表節點（fh>0）,則得到的結點就是hash值相同的節點組成的鏈表的頭節點。需要依次向後遍歷確定這個新加入的值所在位置。如果遇到hash值與key值都與新加入節點是一致的情況，則只需要更新value值即可。否則依次向後遍歷，直到鏈表尾插入這個結點。
   如果加入這個節點以後鏈表長度大於8，就把這個鏈表轉換成紅黑樹。如果這個節點的類型已經是樹節點的話，直接調用樹節點的插入方法進行插入新的值。

3、初始化initTable

調用ConcurrentHashMap的構造方法僅僅是設置了一些參數而已，而整個table的初始化是在向ConcurrentHashMap中插入元素的時候發生的。如調用put、computeIfAbsent、compute、merge等方法的時候，調用時機是檢查table==null。

初始化方法主要應用了關鍵屬性sizeCtl 如果這個值 < 0，表示其他線程正在進行初始化，就放棄這個操作。

在這也可以看出ConcurrentHashMap的初始化只能由一個線程完成。如果獲得了初始化權限，就用CAS方法將sizeCtl置爲-1，防止其他線程進入。初始化數組後，將sizeCtl的值改爲0.75*n

private final Node<K,V>[] initTable() {
    Node<K,V>[] tab; int sc;
    while ((tab = table) == null || tab.length == 0) {
        // 初始化的"功勞"被其他線程"搶去"了
        if ((sc = sizeCtl) < 0)
            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) {
                    // DEFAULT_CAPACITY 默認初始容量是 16
                    int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
                    // 初始化數組，長度爲 16 或初始化時提供的長度
                    Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
                    // 將這個數組賦值給 table，table 是 volatile 的
                    table = tab = nt;
                    // 如果 n 爲 16 的話，那麼這裏 sc = 12
                    // 其實就是 0.75 * n
                    sc = n - (n >>> 2);
                }
            } finally {
                // 設置 sizeCtl 爲 sc，我們就當是 12 吧
                sizeCtl = sc;
            }
            break;
        }
    }
    return tab;
}

所以初始化方法中的併發問題是通過對 sizeCtl 進行一個 CAS 操作來控制的。

4、鏈表轉紅黑樹: treeifyBin

treeifyBin 不一定就會進行紅黑樹轉換，也可能是僅僅做數組擴容

private final void treeifyBin(Node<K,V>[] tab, int index) {
    Node<K,V> b; int n, sc;
    if (tab != null) {
        // MIN_TREEIFY_CAPACITY 爲 64
        // 所以，如果數組長度小於 64 的時候，其實也就是 32 或者 16 或者更小的時候，會進行數組擴容
        if ((n = tab.length) < MIN_TREEIFY_CAPACITY)
            // 後面我們再詳細分析這個方法
            tryPresize(n << 1);
        // b 是頭結點
        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));
                }
            }
        }
    }
}

treeifyBin是在鏈表長度達到一定閾值（8）後轉換成紅黑樹的函數。 但是並不是直接轉換，而是進行一次容量判斷，如果容量沒有達到轉換的要求，直接進行擴容操作並返回；如果滿足條件纔將鏈表的結構轉換爲TreeBin ，這與HashMap不同的是，它並沒有把TreeNode直接放入紅黑樹，而是利用了TreeBin這個小容器來封裝所有的TreeNode。

5、擴容：tryPresize

tryPresize做翻倍擴容的，擴容後數組容量爲原來的 2 倍。

// 首先要說明的是，方法參數 size 傳進來的時候就已經翻了倍了
private final void tryPresize(int size) {
    // c：size 的 1.5 倍，再加 1，再往上取最近的 2 的 n 次方。
    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;

        // 這個 if 分支和之前說的初始化數組的代碼基本上是一樣的，在這裏，我們可以不用管這塊代碼
        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); // 0.75 * n
                    }
                } finally {
                    sizeCtl = sc;
                }
            }
        }
        else if (c <= sc || n >= MAXIMUM_CAPACITY)
            break;
        else if (tab == table) {
            // 我沒看懂 rs 的真正含義是什麼，不過也關係不大
            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;
                // 2. 用 CAS 將 sizeCtl 加 1，然後執行 transfer 方法
                //    此時 nextTab 不爲 null
                if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
                    transfer(tab, nt);
            }
            // 1. 將 sizeCtl 設置爲 (rs << RESIZE_STAMP_SHIFT) + 2)
            //     我是沒看懂這個值真正的意義是什麼？不過可以計算出來的是，結果是一個比較大的負數
            //  調用 transfer 方法，此時 nextTab 參數爲 null
            else if (U.compareAndSwapInt(this, SIZECTL, sc,
                                         (rs << RESIZE_STAMP_SHIFT) + 2))
                transfer(tab, null);
        }
    }
}

這個方法的核心在於 sizeCtl 值的操作，首先將其設置爲一個負數，然後執行 transfer(tab, null)，再下一個循環將 sizeCtl 加 1，並執行 transfer(tab, nt)，之後可能是繼續 sizeCtl 加 1，並執行 transfer(tab, nt)。

所以，可能的操作就是執行 1 次 transfer(tab, null) + 多次 transfer(tab, nt)，這裏怎麼結束循環的需要看完 transfer 源碼才清楚。

6、數據遷移：transfer

將原來的 tab 數組的元素遷移到新的 nextTab 數組中。
支持多線程進行擴容操作，並沒有加鎖 ，這樣做的目的不僅僅是爲了滿足concurrent的要求，而是希望利用併發處理去減少擴容帶來的時間影響。

在進行多線程操作時，多線程執行，外圍調用此方法的時候，會保證第一個發起數據遷移的線程，nextTab 參數爲 null，之後再調用此方法的時候，nextTab 不會爲 null。

併發操作的機制。原數組長度爲 n，所以我們有 n 個遷移任務，讓每個線程每次負責一個小任務是最簡單的，每做完一個任務再檢測是否有其他沒做完的任務，幫助遷移就可以了，而 Doug Lea 使用了一個 stride，簡單理解就是步長，每個線程每次負責遷移其中的一部分，如每次遷移 16 個小任務。所以，我們就需要一個全局的調度者來安排哪個線程執行哪幾個任務，這個就是屬性 transferIndex 的作用。

第一個發起數據遷移的線程會將 transferIndex 指向原數組最後的位置，然後從後往前的 stride 個任務屬於第一個線程，然後將 transferIndex 指向新的位置，再往前的 stride 個任務屬於第二個線程，依此類推。當然，這裏說的第二個線程不是真的一定指代了第二個線程，也可以是同一個線程，這個讀者應該能理解吧。其實就是將一個大的遷移任務分爲了一個個任務包。

/**
   * 一個過渡的table表  只有在擴容的時候纔會使用
   */
  private transient volatile Node<K,V>[] nextTable;
 
/**
   * Moves and/or copies the nodes in each bin to new table. See
   * above for explanation.
   */
  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) {            // initiating
          try {
              @SuppressWarnings("unchecked")
              Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1];//構造一個nextTable對象 它的容量是原來的兩倍
              nextTab = nt;
          } catch (Throwable ex) {      // try to cope with OOME
              sizeCtl = Integer.MAX_VALUE;
              return;
          }
          nextTable = nextTab;
          transferIndex = n;
      }
      int nextn = nextTab.length;
      ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);//構造一個連節點指針 用於標誌位
      boolean advance = true;//併發擴容的關鍵屬性 如果等於true 說明這個節點已經處理過
      boolean finishing = false; // to ensure sweep before committing nextTab
      for (int i = 0, bound = 0;;) {
          Node<K,V> f; int fh;
          //這個while循環體的作用就是在控制i--  通過i--可以依次遍歷原hash表中的節點
          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賦值給table 清空臨時對象nextTable
                  nextTable = null;
                  table = nextTab;
                  sizeCtl = (n << 1) - (n >>> 1);//擴容閾值設置爲原來容量的1.5倍  依然相當於現在容量的0.75倍
                  return;
              }
              //利用CAS方法更新這個擴容閾值，在這裏面sizectl值減一，說明新加入一個線程參與到擴容操作
              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
              }
          }
          //如果遍歷到的節點爲空 則放入ForwardingNode指針
          else if ((f = tabAt(tab, i)) == null)
              advance = casTabAt(tab, i, null, fwd);
          //如果遍歷到ForwardingNode節點  說明這個點已經被處理過了 直接跳過  這裏是控制併發擴容的核心
          else if ((fh = f.hash) == MOVED)
              advance = true; // already processed
          else {
                //節點上鎖
              synchronized (f) {
                  if (tabAt(tab, i) == f) {
                      Node<K,V> ln, hn;
                      //如果fh>=0 證明這是一個Node節點
                      if (fh >= 0) {
                          int runBit = fh & n;
                          //以下的部分在完成的工作是構造兩個鏈表  一個是原鏈表  另一個是原鏈表的反序排列
                          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;
                              }
                          }
                          if (runBit == 0) {
                              ln = lastRun;
                              hn = null;
                          }
                          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);
                          }
                          //在nextTable的i位置上插入一個鏈表
                          setTabAt(nextTab, i, ln);
                          //在nextTable的i+n的位置上插入另一個鏈表
                          setTabAt(nextTab, i + n, hn);
                          //在table的i位置上插入forwardNode節點  表示已經處理過該節點
                          setTabAt(tab, i, fwd);
                          //設置advance爲true 返回到上面的while循環中 就可以執行i--操作
                          advance = true;
                      }
                      //對TreeBin對象進行處理  與上面的過程類似
                      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;
                              }
                          }
                          //如果擴容後已經不再需要tree的結構 反向轉換爲鏈表結構
                          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;
                           //在nextTable的i位置上插入一個鏈表    
                          setTabAt(nextTab, i, ln);
                          //在nextTable的i+n的位置上插入另一個鏈表
                          setTabAt(nextTab, i + n, hn);
                           //在table的i位置上插入forwardNode節點  表示已經處理過該節點
                          setTabAt(tab, i, fwd);
                          //設置advance爲true 返回到上面的while循環中 就可以執行i--操作
                          advance = true;
                      }
                  }
              }
          }
      }
  }

7、協助擴容helpTransfer

這個方法被調用的時候，當前ConcurrentHashMap一定已經有了nextTable對象，首先拿到這個nextTable對象，調用上面講到的transfer方法來進行擴容。

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;
            if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)) {
                transfer(tab, nextTab);
                break;
            }
        }
        return nextTab;
    }
    return table;
}

8、get 過程分析

get的大致流程：
1、計算 hash 值
2、根據 hash 值找到數組對應位置: (n - 1) & h
3、根據該位置處結點性質進行相應查找

public V get(Object key) {
    Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
    //計算hash值
    int h = spread(key.hashCode());
    //根據hash值確定節點位置
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (e = tabAt(tab, (n - 1) & h)) != null) {
        //如果搜索到的節點key與傳入的key相同且不爲null,直接返回這個節點  
        if ((eh = e.hash) == h) {
            if ((ek = e.key) == key || (ek != null && key.equals(ek)))
                return e.val;
        }
        //如果eh<0 說明這個節點在樹上 直接尋找
        else if (eh < 0)
            return (p = e.find(h, key)) != null ? p.val : null;
         //否則遍歷鏈表 找到對應的值並返回
        while ((e = e.next) != null) {
            if (e.hash == h &&
                ((ek = e.key) == key || (ek != null && key.equals(ek))))
                return e.val;
        }
    }
    return null;
}

以上的代碼和文章來自：https://blog.csdn.net/weixin_28760063/article/details/81211988、https://blog.csdn.net/sihai12345/article/details/79383766

以上就是從源碼分析ConcurrentHashMap的put、get、transfer、等方法，從源碼看這些實現方法，雖然不一定能看得懂，但是從源碼中我們可以瞭解實現流程是怎樣的，以及在執行數據遷移時我們需要做哪些處理？又是如何實現的多線程操作？等問題，我想能初步瞭解了這些，後面也可以繼續加深對源碼的認識了！

結語：

我是走在學習路上、膜拜大佬的程序員！

學習不停、膜拜不停！