@Service
public class Counter {
    private final ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();

    public void increase(String key) {
        map.compute(key, (k, v) -> (v == null) ? 1 : v + 1);
    }

    public int get(String key) {
        return map.getOrDefault(key, 0);
    }
}

import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicLong;
import java.util.function.Function;

/**
 * 高性能并發(fā)緩存管理器
 * @param <K> 鍵類型
 * @param <V> 值類型
 */
publicclass ConcurrentCache<K, V> {

    privatefinal ConcurrentHashMap<K, CacheEntry<V>> cache = new ConcurrentHashMap<>();
    privatefinal Function<K, V> loader;  // 緩存加載器
    privatefinal ScheduledExecutorService cleaner;  // 過(guò)期清理線程

    // 默認(rèn)配置
    privatelong defaultTTL = 30_000;          // 默認(rèn)30秒
    privatelong cleanupInterval = 5_000;      // 5秒清理一次
    privateint maxRetries = 3;                // 最大重試次數(shù)
    privateboolean refreshOnAccess = true;    // 訪問(wèn)時(shí)刷新TTL

    public ConcurrentCache(Function<K, V> loader) {
        this.loader = loader;
        this.cleaner = Executors.newSingleThreadScheduledExecutor();
        startCleanupTask();
    }

    /**
     * 獲取緩存值（線程安全）
     */
    public V get(K key) {
        CacheEntry<V> entry = cache.get(key);

        // 無(wú)緩存或已過(guò)期時(shí)加載
        if (entry == null || entry.isExpired()) {
            return loadAndCache(key);
        }

        // 更新訪問(wèn)時(shí)間（可選）
        if (refreshOnAccess) {
            entry.touch();
        }
        return entry.value;
    }

    /**
     * 原子性的加載和緩存操作
     */
    private V loadAndCache(K key) {
        int retry = 0;
        while (retry++ < maxRetries) {
            try {
                // 使用compute保證原子性
                CacheEntry<V> newEntry = cache.compute(key, (k, oldEntry) -> {
                    // 檢查其他線程是否已經(jīng)加載
                    if (oldEntry != null && !oldEntry.isExpired()) {
                        return oldEntry;
                    }

                    V value = loader.apply(k);
                    returnnew CacheEntry<>(value, defaultTTL, TimeUnit.MILLISECONDS);
                });

                return newEntry.value;
            } catch (Exception ex) {
                if (retry >= maxRetries) {
                    thrownew CacheLoadException("加載緩存失敗，key=" + key, ex);
                }
                // 指數(shù)退避重試
                sleepUninterruptibly((long) Math.pow(2, retry), TimeUnit.MILLISECONDS);
            }
        }
        thrownew CacheLoadException("超過(guò)最大重試次數(shù)，key=" + key);
    }

    /**
     * 主動(dòng)放入緩存（支持自定義TTL）
     */
    public void put(K key, V value, long ttl, TimeUnit unit) {
        cache.put(key, new CacheEntry<>(value, ttl, unit));
    }

    /**
     * 啟動(dòng)定期清理任務(wù)（雙重檢查鎖模式）
     */
    private void startCleanupTask() {
        if (cleaner.isShutdown()) return;

        cleaner.scheduleWithFixedDelay(() -> {
            cache.forEach((key, entry) -> {
                if (entry.isExpired()) {
                    cache.remove(key, entry); // 使用CAS刪除
                }
            });
        }, cleanupInterval, cleanupInterval, TimeUnit.MILLISECONDS);
    }

    // 其他實(shí)用方法
    public void remove(K key) { cache.remove(key); }
    public void clear() { cache.clear(); }
    public long size() { return cache.mappingCount(); }

    // 配置方法（Builder模式風(fēng)格）
    public ConcurrentCache<K, V> defaultTTL(long ttl, TimeUnit unit) {
        this.defaultTTL = unit.toMillis(ttl);
        returnthis;
    }

    public ConcurrentCache<K, V> cleanupInterval(long interval, TimeUnit unit) {
        this.cleanupInterval = unit.toMillis(interval);
        returnthis;
    }

    // 異常處理
    privatestaticclass CacheLoadException extends RuntimeException {
        CacheLoadException(String message, Throwable cause) {
            super(message, cause);
        }

        CacheLoadException(String message) {
            super(message);
        }
    }

    // 工具方法：不可中斷的休眠
    private static void sleepUninterruptibly(long duration, TimeUnit unit) {
        try {
            Thread.sleep(unit.toMillis(duration));
        } catch (InterruptedException ignored) {
            Thread.currentThread().interrupt();
        }
    }

    // 關(guān)閉時(shí)釋放資源
    public void shutdown() {
        cleaner.shutdownNow();
        cache.clear();
    }

    // 緩存條目：包含值、過(guò)期時(shí)間和訪問(wèn)時(shí)間戳
    privatestaticclass CacheEntry<V> {
        final V value;
        finallong expireAt;  // 絕對(duì)過(guò)期時(shí)間（納秒）
        final AtomicLong accessTime = new AtomicLong(); // 最后訪問(wèn)時(shí)間（納秒）

        CacheEntry(V value, long ttl, TimeUnit unit) {
            this.value = value;
            this.expireAt = System.nanoTime() + unit.toNanos(ttl);
            touch();
        }
        // 刷新訪問(wèn)時(shí)間
        void touch() {
            accessTime.set(System.nanoTime());
        }
        // 判斷是否已過(guò)期
        boolean isExpired() {
            return System.nanoTime() > expireAt;
        }
    }
}

// node數(shù)組最大容量：2^30=1073741824
privatestaticfinalint MAXIMUM_CAPACITY = 1 << 30;
// 默認(rèn)初始值，必須是2的幕數(shù)
privatestaticfinalint DEFAULT_CAPACITY = 16;
//數(shù)組可能最大值，需要與toArray（）相關(guān)方法關(guān)聯(lián)
staticfinalint MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
//并發(fā)級(jí)別，遺留下來(lái)的，為兼容以前的版本
privatestaticfinalint DEFAULT_CONCURRENCY_LEVEL = 16;
// 負(fù)載因子
privatestaticfinalfloat LOAD_FACTOR = 0.75f;
// 鏈表轉(zhuǎn)紅黑樹閥值,> 8 鏈表轉(zhuǎn)換為紅黑樹
staticfinalint TREEIFY_THRESHOLD = 8;
//樹轉(zhuǎn)鏈表閥值，小于等于6（tranfer時(shí)，lc、hc=0兩個(gè)計(jì)數(shù)器分別++記錄原bin、新binTreeNode數(shù)量，<=UNTREEIFY_THRESHOLD 則untreeify(lo)）
staticfinalint UNTREEIFY_THRESHOLD = 6;
staticfinalint MIN_TREEIFY_CAPACITY = 64;
privatestaticfinalint MIN_TRANSFER_STRIDE = 16;
privatestaticint RESIZE_STAMP_BITS = 16;
// 2^15-1，help resize的最大線程數(shù)
privatestaticfinalint MAX_RESIZERS = (1 << (32 - RESIZE_STAMP_BITS)) - 1;
// 32-16=16，sizeCtl中記錄size大小的偏移量
privatestaticfinalint RESIZE_STAMP_SHIFT = 32 - RESIZE_STAMP_BITS;
// forwarding nodes的hash值
staticfinalint MOVED     = -1;
// 樹根節(jié)點(diǎn)的hash值
staticfinalint TREEBIN   = -2;
// ReservationNode的hash值
staticfinalint RESERVED  = -3;
// 可用處理器數(shù)量
staticfinalint NCPU = Runtime.getRuntime().availableProcessors();
//存放node的數(shù)組
transientvolatile Node<K,V>[] table;
/*控制標(biāo)識(shí)符，用來(lái)控制table的初始化和擴(kuò)容的操作，不同的值有不同的含義
 *當(dāng)為負(fù)數(shù)時(shí)：-1代表正在初始化，-N代表有N-1個(gè)線程正在 進(jìn)行擴(kuò)容
 *當(dāng)為0時(shí)：代表當(dāng)時(shí)的table還沒(méi)有被初始化
 *當(dāng)為正數(shù)時(shí)：表示初始化或者下一次進(jìn)行擴(kuò)容的大小
 */
privatetransientvolatileint sizeCtl;

static class Node<K,V> implements Map.Entry<K,V> {  // 哈希表普通節(jié)點(diǎn)
finalint hash;
final K key;
volatile V val;
volatile Node<K,V> next;

Node<K,V> find(int h, Object k) {}   // 主要在擴(kuò)容時(shí)，利用多態(tài)查詢已轉(zhuǎn)移節(jié)點(diǎn)
}

staticfinalclass ForwardingNode<K,V> extends Node<K,V> {  // 標(biāo)識(shí)擴(kuò)容節(jié)點(diǎn)
final Node<K,V>[] nextTable;  // 指向成員變量 ConcurrentHashMap.nextTable

  ForwardingNode(Node<K,V>[] tab) {
    super(MOVED, null, null, null);  // hash = -1，快速確定 ForwardingNode 節(jié)點(diǎn)
    this.nextTable = tab;
  }

Node<K,V> find(int h, Object k) {}
}

staticfinalclass TreeBin<K,V> extends Node<K,V> { // 紅黑樹根節(jié)點(diǎn)
  TreeBin(TreeNode<K,V> b) {
    super(TREEBIN, null, null, null);  // hash = -2，快速確定紅黑樹，
    ...
  }
}
staticfinalclass TreeNode<K,V> extends Node<K,V> { } // 紅黑樹普通節(jié)點(diǎn)，其 hash 同 Node 普通節(jié)點(diǎn) > 0；

static finalint MOVED     = -1;          // hash for forwarding nodes
staticfinalint TREEBIN   = -2;          // hash for roots of trees
staticfinalint RESERVED  = -3;          // hash for transient reservations
staticfinalint HASH_BITS = 0x7fffffff;  // usable bits of normal node hash

// 讓高位16位，參與哈希桶定位運(yùn)算的同時(shí)，保證 hash 為正
static final int spread(int h) {
return (h ^ (h >>> 16)) & HASH_BITS;
}

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

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

staticfinal <K,V> void setTabAt(Node<K,V>[] tab, int i, Node<K,V> v) {
  U.putObjectVolatile(tab, ((long)i << ASHIFT) + ABASE, v);
}

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) thrownew NullPointerException();
    int hash = spread(key.hashCode()); //兩次hash，減少hash沖突，可以均勻分布
    int binCount = 0;
    for (Node<K,V>[] tab = table;;) { //對(duì)這個(gè)table進(jìn)行迭代
        Node<K,V> f; int n, i, fh;
        //這里就是上面構(gòu)造方法沒(méi)有進(jìn)行初始化，在這里進(jìn)行判斷，為null就調(diào)用initTable進(jìn)行初始化，屬于懶漢模式初始化
        if (tab == null || (n = tab.length) == 0)
            tab = initTable();
        elseif ((f = tabAt(tab, i = (n - 1) & hash)) == null) {//如果i位置沒(méi)有數(shù)據(jù)，就直接無(wú)鎖插入
            if (casTabAt(tab, i, null,
                         new Node<K,V>(hash, key, value, null)))
                break;                   // no lock when adding to empty bin
        }
        elseif ((fh = f.hash) == MOVED)//如果在進(jìn)行擴(kuò)容，則先進(jìn)行擴(kuò)容操作
            tab = helpTransfer(tab, f);
        else {
            V oldVal = null;
            //如果以上條件都不滿足，那就要進(jìn)行加鎖操作，也就是存在hash沖突，鎖住鏈表或者紅黑樹的頭結(jié)點(diǎn)
            synchronized (f) {
                if (tabAt(tab, i) == f) {
                    if (fh >= 0) { //表示該節(jié)點(diǎn)是鏈表結(jié)構(gòu)
                        binCount = 1;
                        for (Node<K,V> e = f;; ++binCount) {
                            K ek;
                            //這里涉及到相同的key進(jìn)行put就會(huì)覆蓋原先的value
                            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;
                            }
                        }
                    }
                    elseif (f instanceof TreeBin) {//紅黑樹結(jié)構(gòu)
                        Node<K,V> p;
                        binCount = 2;
                        //紅黑樹結(jié)構(gòu)旋轉(zhuǎn)插入
                        if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
                                                       value)) != null) {
                            oldVal = p.val;
                            if (!onlyIfAbsent)
                                p.val = value;
                        }
                    }
                }
            }
            if (binCount != 0) { //如果鏈表的長(zhǎng)度大于8時(shí)就會(huì)進(jìn)行紅黑樹的轉(zhuǎn)換
                if (binCount >= TREEIFY_THRESHOLD)
                    treeifyBin(tab, i);
                if (oldVal != null)
                    return oldVal;
                break;
            }
        }
    }
    addCount(1L, binCount);//統(tǒng)計(jì)size，并且檢查是否需要擴(kuò)容
    returnnull;
}

public V get(Object key) {
  Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
int h = spread(key.hashCode()); // 計(jì)算 hash
if ((tab = table) != null && (n = tab.length) > 0 &&  // 確保 table 已經(jīng)初始化

    // 確保對(duì)應(yīng)的哈希桶不為空，注意這里是 Volatile 語(yǔ)義獲??；因?yàn)閿U(kuò)容的時(shí)候，是完全拷貝，所以只要不為空，則鏈表必然完整
    (e = tabAt(tab, (n - 1) & h)) != null) {
    if ((eh = e.hash) == h) {
      if ((ek = e.key) == key || (ek != null && key.equals(ek)))
        return e.val;
    }

    // hash < 0，則必然在擴(kuò)容，原來(lái)位置的節(jié)點(diǎn)可能全部移動(dòng)到 i + oldCap 位置，所以利用多態(tài)到 nextTable 中查找
    elseif (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;
    }
  }
returnnull;
}

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; // 根據(jù) CPU 數(shù)量計(jì)算任務(wù)步長(zhǎng)
if (nextTab == null) {          // 初始化 nextTab
    try {
      @SuppressWarnings("unchecked")
      Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1];  // 擴(kuò)容一倍
      nextTab = nt;
    } catch (Throwable ex) {
      sizeCtl = Integer.MAX_VALUE; // 發(fā)生 OOM 時(shí)，不再擴(kuò)容
      return;
    }
    nextTable = nextTab;
    transferIndex = n;
  }
int nextn = nextTab.length;
  ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);  // 標(biāo)記空桶，或已經(jīng)轉(zhuǎn)移完畢的桶
boolean advance = true;
boolean finishing = false; // to ensure sweep before committing nextTab
for (int i = 0, bound = 0;;) {  // 逆向遍歷擴(kuò)容
    Node<K,V> f; int fh;
    while (advance) {  // 向前獲取哈希桶
      int nextIndex, nextBound;
      if (--i >= bound || finishing)               // 已經(jīng)取到哈希桶，或已完成時(shí)退出
        advance = false;
      elseif ((nextIndex = transferIndex) <= 0) { // 遍歷到達(dá)頭節(jié)點(diǎn)，已經(jīng)沒(méi)有待遷移的桶，線程準(zhǔn)備退出
        i = -1;
        advance = false;
      }
      elseif (U.compareAndSwapInt
           (this, TRANSFERINDEX, nextIndex,
            nextBound = (nextIndex > stride ? nextIndex - stride : 0))) {  // 當(dāng)前任務(wù)完成，領(lǐng)取下一批哈希桶
        bound = nextBound;
        i = nextIndex - 1;  // 索引指向下一批哈希桶
        advance = false;
      }
    }

    // i < 0  ：表示擴(kuò)容結(jié)束，已經(jīng)沒(méi)有待移動(dòng)的哈希桶
    // i >= n ：擴(kuò)容結(jié)束，再次檢查確認(rèn)
    // i + n >= nextn ： 在使用 nextTable 替換 table 時(shí)，有線程進(jìn)入擴(kuò)容就會(huì)出現(xiàn)
    if (i < 0 || i >= n || i + n >= nextn) { // 完成擴(kuò)容準(zhǔn)備退出
      int sc;
      if (finishing) {  // 兩次檢查，只有最后一個(gè)擴(kuò)容線程退出時(shí)，才更新變量
        nextTable = null;
        table = nextTab;
        sizeCtl = (n << 1) - (n >>> 1); // 0.75*2*n
        return;
      }
      if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {  // 擴(kuò)容線程減一
        if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT) return;  // 不是最后一個(gè)線程，直接退出
        finishing = advance = true;   // 最后一個(gè)線程，再次檢查
        i = n;                        // recheck before commit
      }
    }
    elseif ((f = tabAt(tab, i)) == null)  // 當(dāng)前節(jié)點(diǎn)為空，直接標(biāo)記為 ForwardingNode，然后繼續(xù)獲取下一個(gè)桶
      advance = casTabAt(tab, i, null, fwd);

    // 之前的線程已經(jīng)完成該桶的移動(dòng)，直接跳過(guò)，正常情況下自己的任務(wù)區(qū)間，不會(huì)出現(xiàn) ForwardingNode 節(jié)點(diǎn)，
    elseif ((fh = f.hash) == MOVED)  // 此處為極端條件下的健壯性檢查
      advance = true; // already processed

    // 開始處理鏈表
    else {
      // 注意在 get 的時(shí)候，可以無(wú)鎖獲取，是因?yàn)閿U(kuò)容是全拷貝節(jié)點(diǎn)，完成后最后在更新哈希桶
      // 而在 put 的時(shí)候，是直接將節(jié)點(diǎn)加入尾部，獲取修改其中的值，此時(shí)如果允許 put 操作，最后就會(huì)發(fā)生臟讀，
      // 所以 put 和 transfer，需要競(jìng)爭(zhēng)同一把鎖，也就是對(duì)應(yīng)的哈希桶，以保證內(nèi)存一致性效果
      synchronized (f) {
        if (tabAt(tab, i) == f) {  // 確認(rèn)鎖定的是同一個(gè)桶
          Node<K,V> ln, hn;
          if (fh >= 0) {  // 正常節(jié)點(diǎn)
            int runBit = fh & n;  // hash & n，判斷擴(kuò)容后的索引
            Node<K,V> lastRun = f;

            // 此處找到鏈表最后擴(kuò)容后處于同一位置的連續(xù)節(jié)點(diǎn)，這樣最后一節(jié)就不用再一次復(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;
            }

            // 依次將鏈表拆分成，lo、hi 兩條鏈表，即位置不變的鏈表，和位置 + oldCap 的鏈表
            // 注意最后一節(jié)鏈表沒(méi)有new，而是直接使用原來(lái)的節(jié)點(diǎn)
            // 同時(shí)鏈表的順序也被打亂了，lastRun 到最后為正序，前面一節(jié)為逆序
            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);
            }
            setTabAt(nextTab, i, ln);      // 插入 lo 鏈表
            setTabAt(nextTab, i + n, hn);  // 插入 hi 鏈表
            setTabAt(tab, i, fwd);         // 哈希桶移動(dòng)完成，標(biāo)記為 ForwardingNode 節(jié)點(diǎn)
            advance = true;                // 繼續(xù)獲取下一個(gè)桶
          }
          elseif (f instanceof TreeBin) { // 拆分紅黑樹
            TreeBin<K,V> t = (TreeBin<K,V>)f;
            TreeNode<K,V> lo = null, loTail = null; // 為避免最后在反向遍歷，先留頭結(jié)點(diǎn)的引用，
            TreeNode<K,V> hi = null, hiTail = null; // 因?yàn)轫樞虻逆湵恚梢约铀偌t黑樹構(gòu)造
            int lc = 0, hc = 0;  // 同樣記錄 lo，hi 鏈表的長(zhǎng)度
            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);  // 構(gòu)造紅黑樹節(jié)點(diǎn)
              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;
              }
            }

            // 判斷是否需要將其轉(zhuǎn)化為紅黑樹，同時(shí)如果只有一條鏈，那么就可以不用在構(gòu)造
            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;
          }
        }
      }
    }
  }
}

// 訂單事件處理器（生產(chǎn)環(huán)境級(jí)實(shí)現(xiàn)）
publicclass OrderEventProcessor {
    // 使用隊(duì)列作為訂單緩沖區(qū)（無(wú)容量限制）
    privatefinal ConcurrentLinkedQueue<OrderEvent> queue = new ConcurrentLinkedQueue<>();
    privatefinal ExecutorService workers = Executors.newFixedThreadPool(
        Runtime.getRuntime().availableProcessors() * 2,
        new NamedThreadFactory("order-processor")
    );

    // 初始化處理線程
    public void start() {
        for (int i = 0; i < workers.getCorePoolSize(); i++) {
            workers.submit(this::processEvents);
        }
    }

    // 接收訂單事件（來(lái)自網(wǎng)絡(luò)IO線程）
    public void receiveEvent(OrderEvent event) {
        queue.offer(event); // 無(wú)阻塞插入
        metrics.recordEnqueue(); // 監(jiān)控埋點(diǎn)
    }

    // 事件處理核心邏輯
    private void processEvents() {
        while (!Thread.currentThread().isInterrupted()) {
            OrderEvent event = queue.poll(); // 無(wú)阻塞獲取
            if (event != null) {
                try {
                    handleEvent(event);
                } catch (Exception ex) {
                    handleFailure(event, ex); // 異常處理
                }
            } else {
                // 隊(duì)列空時(shí)自適應(yīng)休眠（避免CPU空轉(zhuǎn)）
                sleepBackoff();
            }
        }
    }

    // 指數(shù)退避休眠（動(dòng)態(tài)調(diào)節(jié)CPU使用率）
    private void sleepBackoff() {
        long delay = 1; // 初始1ms
        while (queue.isEmpty() && delay < 100) {
            try {
                TimeUnit.MILLISECONDS.sleep(delay);
                delay <<= 1; // 指數(shù)增加等待時(shí)間
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }

    // 優(yōu)雅關(guān)閉
    public void shutdown() {
        workers.shutdown();
        while (!queue.isEmpty()) {
            // 等待剩余任務(wù)處理完成
            Uninterruptibles.sleepUninterruptibly(100, TimeUnit.MILLISECONDS);
        }
    }
}

static finalclass Node<E> {
    volatile E item;
    volatile Node<E> next;


    Node(E item) {
        ITEM.set(this, item);
    }


    Node() {}

    void appendRelaxed(Node<E> next) {

        NEXT.set(this, next);
    }

    boolean casItem(E cmp, E val) {
        return ITEM.compareAndSet(this, cmp, val);
    }
}

public boolean offer(E e) {
    final Node<E> newNode = new Node<E>(Objects.requireNonNull(e));

    for (Node<E> t = tail, p = t;;) {
        Node<E> q = p.next;
        if (q == null) {
            // CAS插入新節(jié)點(diǎn)
            if (NEXT.compareAndSet(p, null, newNode)) {
                // 惰性更新tail（允許失?。?                if (p != t)
                    TAIL.weakCompareAndSet(this, t, newNode);
                returntrue;
            }
        }
        elseif (p == q) // 處理已移除節(jié)點(diǎn)
            p = (t != (t = tail)) ? t : head;
        else// 推進(jìn)指針
            p = (p != t && t != (t = tail)) ? t : q;
    }
}

public E poll() {
    restartFromHead:
    for (;;) {
        for (Node<E> h = head, p = h, q;;) {
            E item;
            if ((item = p.item) != null && p.casItem(item, null)) {
                // 成功獲取數(shù)據(jù)
                if (p != h)
                    updateHead(h, ((q = p.next) != null) ? q : p);
                return item;
            }
            elseif ((q = p.next) == null) {
                updateHead(h, p);
                returnnull;
            }
            elseif (p == q)
              // 繼續(xù)循環(huán)
                 continue restartFromHead;
        }
    }
}

//插入元素，隊(duì)列滿后會(huì)拋出異常
boolean add(E e);
//移除元素，隊(duì)列為空時(shí)會(huì)拋出異常
E remove();

//插入元素，成功反會(huì)true
boolean offer(E e);
//移除元素
E poll();

//插入元素，隊(duì)列滿后會(huì)阻塞
void put(E e) throws InterruptedException;
//移除元素，隊(duì)列空后會(huì)阻塞
E take() throws InterruptedException;

//限時(shí)插入
boolean offer(E e, long timeout, TimeUnit unit)
//限時(shí)移除
E poll(long timeout, TimeUnit unit);

//獲取所有元素到Collection中
int drainTo(Collection<? super E> c);

public class OrderProcessor {
    // 生產(chǎn)級(jí)配置：建議隊(duì)列大小為 CPU 核心數(shù)*2~4
    privatestaticfinal BlockingQueue<Order> queue = new LinkedBlockingQueue<>(2048);
    privatestaticfinal ExecutorService consumerPool = Executors.newFixedThreadPool(8);

    // 生產(chǎn)者（Web 服務(wù)線程）
    public void submitOrder(Order order) {
        if (!queue.offer(order)) {  // 隊(duì)列滿時(shí)快速失敗
            log.warn("Order queue overflow! Reject order: {}", order.getId());
            thrownew ServiceException("系統(tǒng)繁忙，請(qǐng)稍后重試");
        }
        log.info("Order submitted: {}", order.getId());
    }

    // 消費(fèi)者（后臺(tái)線程池）
    @PostConstruct
    public void initConsumers() {
        for (int i = 0; i < 8; i++) {
            consumerPool.execute(() -> {
                while (!Thread.currentThread().isInterrupted()) {
                    try {
                        Order order = queue.take();  // 阻塞直到有訂單
                        processOrder(order);
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                    }
                }
            });
        }
    }

    private void processOrder(Order order) {
        // 扣減庫(kù)存、支付回調(diào)等業(yè)務(wù)邏輯
    }
}

public class VideoTranscoder {
    // 使用 PriorityBlockingQueue 確保 VIP 用戶優(yōu)先處理
    privatestaticfinal BlockingQueue<TranscodeTask> queue =
        new PriorityBlockingQueue<>(1000, Comparator.comparing(TranscodeTask::getPriority));

    // 自定義線程池（核心線程數(shù)=CPU數(shù), 最大線程數(shù)=CPU數(shù)*2）
    privatestaticfinal ThreadPoolExecutor executor = new ThreadPoolExecutor(
        4, 8, 30, TimeUnit.SECONDS, queue
    );

    public void submitTranscodeTask(TranscodeTask task) {
        executor.execute(() -> {
            // 執(zhí)行實(shí)際轉(zhuǎn)碼操作
            process(task);
        });
    }

    // 監(jiān)控隊(duì)列狀態(tài)（生產(chǎn)環(huán)境建議接入 Prometheus）
    public MonitorData getQueueStatus() {
        returnnew MonitorData(
            queue.size(),
            executor.getActiveCount(),
            queue.remainingCapacity()
        );
    }
}

public class SeckillService {
    // 隊(duì)列容量=商品庫(kù)存*2（內(nèi)存可控）
    privatefinal BlockingQueue<SeckillRequest> queue =
        new ArrayBlockingQueue<>(20000);

    // 異步消費(fèi)隊(duì)列
    @Scheduled(fixedRate = 100)
    public void processQueue() {
        List<SeckillRequest> batch = new ArrayList<>(100);
        queue.drainTo(batch, 100);  // 批量取100條
        if (!batch.isEmpty()) {
            seckillDao.batchProcess(batch); // 批量寫入數(shù)據(jù)庫(kù)
        }
    }

    public boolean trySeckill(SeckillRequest request) {
        return queue.offer(request);  // 非阻塞提交
    }
}

public class OrderTimeoutChecker implements Runnable {
    privatefinal DelayQueue<DelayedOrder> queue = new DelayQueue<>();

    public void addOrder(Order order) {
        queue.put(new DelayedOrder(order, 30, TimeUnit.MINUTES));
    }

    @Override
    public void run() {
        while (!Thread.currentThread().isInterrupted()) {
            try {
                DelayedOrder order = queue.take();  // 阻塞直到有到期訂單
                checkPayment(order.getOrderId());
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }

    privatestaticclass DelayedOrder implements Delayed {
        privatefinal Order order;
        privatefinallong expireTime;

        // 實(shí)現(xiàn) getDelay() 和 compareTo()
    }
}

public class AsyncLogger {
    privatestaticfinal BlockingQueue<LogEvent> queue =
        new LinkedTransferQueue<>();  // 高吞吐無(wú)界隊(duì)列

    static {
        // 守護(hù)線程消費(fèi)日志
        Thread loggerThread = new Thread(() -> {
            while (true) {
                try {
                    LogEvent event = queue.take();
                    writeToDisk(event);
                } catch (InterruptedException e) {
                    // 優(yōu)雅關(guān)閉處理
                    drainRemainingLogs();
                    break;
                }
            }
        });
        loggerThread.setDaemon(true);
        loggerThread.start();
    }

    public static void log(LogEvent event) {
        if (!queue.offer(event)) {  // 防御性設(shè)計(jì)
            fallbackLog(event);
        }
    }
}

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler)

// 通過(guò) JMX 暴露指標(biāo)
public class QueueMonitor implements QueueMonitorMXBean {
    private final BlockingQueue<?> queue;

    public int getQueueSize() {
        return queue.size();
    }

    // 注冊(cè)到 MBeanServer...
}

new ThreadPoolExecutor.CallerRunsPolicy() {  // 生產(chǎn)推薦策略
    @Override
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        log.warn("Task rejected, running in caller thread");
        if (!e.isShutdown()) {
            r.run();
        }
    }
}

// 根據(jù)監(jiān)控指標(biāo)調(diào)整隊(duì)列容量
public void adjustQueueCapacity(int newSize) {
    if (queue instanceof ResizableBlockingQueue) {
        ((ResizableBlockingQueue) queue).setCapacity(newSize);
    }
}

public class ArrayBlockingQueue<E> extends AbstractQueue<E> implements BlockingQueue<E>, java.io.Serializable {
    final Object[] items;               // 容器數(shù)組
    int takeIndex;                      // 出隊(duì)索引
    int putIndex;                       // 入隊(duì)索引
    int count;                          // 排隊(duì)個(gè)數(shù)
    final ReentrantLock lock;           // 全局鎖
    private final Condition notEmpty;   // 出隊(duì)條件隊(duì)列
    private final Condition notFull;    // 入隊(duì)條件隊(duì)列
    ...
}

public void put(E e) throws InterruptedException {
    Objects.requireNonNull(e);
    final ReentrantLock lock = this.lock;
    //獲取獨(dú)占鎖
    lock.lockInterruptibly();
    try {
      //如果隊(duì)列已滿則通過(guò)await阻塞put方法
        while (count == items.length)
            notFull.await();
        //滿足條件，插入元素，并喚醒因notEmpty等待的消費(fèi)線程
        enqueue(e);
    } finally {
        lock.unlock();
    }
}

private void enqueue(E x) {
    // assert lock.getHoldCount() == 1;
    // assert items[putIndex] == null;
    final Object[] items = this.items;
    items[putIndex] = x;
//插入元素后將putIndex+1，當(dāng)隊(duì)列使用完后重置為0
    if (++putIndex == items.length)
        putIndex = 0;
    count++;
//隊(duì)列添加元素后喚醒因notEmpty等待的消費(fèi)線程
    notEmpty.signal();
}

//移除隊(duì)列中的元素
public E take() throws InterruptedException {
    final ReentrantLock lock = this.lock;
//獲取獨(dú)占鎖
    lock.lockInterruptibly();
    try {
      //如果隊(duì)列已空則通過(guò)await阻塞take方法
        while (count == 0)
            notEmpty.await();
        return dequeue(); //移除元素
    } finally {
        lock.unlock();
    }
}

private E dequeue() {
    // assert lock.getHoldCount() == 1;
    // assert items[takeIndex] != null;
    final Object[] items = this.items;
    @SuppressWarnings("unchecked")
    E x = (E) items[takeIndex];
    items[takeIndex] = null;
//移除元素后將takeIndex+1，當(dāng)隊(duì)列使用完后重置為0
    if (++takeIndex == items.length)
        takeIndex = 0;
    count--;
    if (itrs != null)
        itrs.elementDequeued();
//隊(duì)列消費(fèi)元素后喚醒因notFull等待的消費(fèi)線程
    notFull.signal();
    return x;
}

public int drainTo(Collection<? super E> c, int maxElements) {
    checkNotNull(c);
    if (c == this)
        thrownew IllegalArgumentException();
    if (maxElements <= 0)
        return0;
    final Object[] items = this.items;
    final ReentrantLock lock = this.lock; //僅獲取一次鎖
    lock.lock();
    try {
        int n = Math.min(maxElements, count); //獲取隊(duì)列中所有元素
        int take = takeIndex;
        int i = 0;
        try {
            while (i < n) {
                @SuppressWarnings("unchecked")
                E x = (E) items[take];
                c.add(x); //循環(huán)插入元素
                items[take] = null;
                if (++take == items.length)
                    take = 0;
                i++;
            }
            return n;
        } finally {
            // Restore invariants even if c.add() threw
            if (i > 0) {
                count -= i;
                takeIndex = take;
                if (itrs != null) {
                    if (count == 0)
                        itrs.queueIsEmpty();
                    elseif (i > take)
                        itrs.takeIndexWrapped();
                }
                for (; i > 0 && lock.hasWaiters(notFull); i--)
                    notFull.signal(); //喚醒等待的生產(chǎn)者線程
            }
        }
    } finally {
        lock.unlock();
    }
}

public class LinkedBlockingQueue<E> extends AbstractQueue<E> implements BlockingQueue<E>, java.io.Serializable {
// 默認(rèn) Integer.MAX_VALUE
privatefinalint capacity;
// 容量
privatefinal AtomicInteger count = new AtomicInteger();
// 頭結(jié)點(diǎn) head.item == null
transient Node<E> head;
// 尾節(jié)點(diǎn) last.next == null
privatetransient Node<E> last;
// take鎖，出隊(duì)鎖，只有take，poll方法會(huì)持有
privatefinal ReentrantLock takeLock = new ReentrantLock();
// 出隊(duì)等待條件
// 當(dāng)隊(duì)列無(wú)元素時(shí)，take鎖會(huì)阻塞在notEmpty條件上，等待其它線程喚醒
privatefinal Condition notEmpty = takeLock.newCondition();
// 入隊(duì)鎖，只有put，offer會(huì)持有
privatefinal ReentrantLock putLock = new ReentrantLock();
// 入隊(duì)等待條件
// 當(dāng)隊(duì)列滿了時(shí)，put鎖會(huì)會(huì)阻塞在notFull上，等待其它線程喚醒
privatefinal Condition notFull = putLock.newCondition();
// 基于鏈表實(shí)現(xiàn)，肯定要有結(jié)點(diǎn)類，典型的單鏈表結(jié)構(gòu)
staticclass Node<E> {
    E item;
    Node<E> next;
    Node(E x) { item = x; }
  }
}

public void put(E e) throws InterruptedException {
    int c = -1;
    Node<E> node = new Node<E>(e);
    final ReentrantLock putLock = this.putLock;
    //因?yàn)槭褂昧穗p鎖，需要使用AtomicInteger計(jì)算元素總量，避免并發(fā)計(jì)算不準(zhǔn)確
    final AtomicInteger count = this.count;
    putLock.lockInterruptibly();
    try {
        while (count.get() == capacity) {
            //隊(duì)列已滿，阻塞生產(chǎn)線程
            notFull.await();
        }
      //插入元素到隊(duì)列尾部
        enqueue(node);
      //count + 1
        c = count.getAndIncrement();
      //如果+1后隊(duì)列還未滿，通過(guò)其他生產(chǎn)線程繼續(xù)生產(chǎn)
        if (c + 1 < capacity)
            notFull.signal();
    } finally {
        putLock.unlock();
    }
//只有當(dāng)之前是空時(shí)，消費(fèi)隊(duì)列才會(huì)阻塞，否則是不需要通知的
    if (c == 0)
        signalNotEmpty();
}

private void enqueue(Node<E> node) {
    //將新元素添加到鏈表末尾，然后將last指向尾部元素
    last = last.next = node;
}

public E take() throws InterruptedException {
    E x;
    int c = -1;
    final AtomicInteger count = this.count;
    final ReentrantLock takeLock = this.takeLock;
    takeLock.lockInterruptibly();
    try {
        while (count.get() == 0) {
          //隊(duì)列為空，阻塞消費(fèi)線程
            notEmpty.await();
        }
      //消費(fèi)一個(gè)元素
        x = dequeue();
      //count - 1
        c = count.getAndDecrement();
      // 通知其他等待的消費(fèi)線程繼續(xù)消費(fèi)
        if (c > 1)
            notEmpty.signal();
    } finally {
        takeLock.unlock();
    }
    if (c == capacity)
      //只有當(dāng)前隊(duì)列是滿的，生產(chǎn)隊(duì)列才會(huì)阻塞，否則是不需要通知的
        signalNotFull();
    return x;
}

//消費(fèi)隊(duì)列頭部的下一個(gè)元素，同時(shí)將新頭部置空
private E dequeue() {
    Node<E> h = head;
    Node<E> first = h.next;
    h.next = h; // help GC
    head = first;
    E x = first.item;
    first.item = null;
    return x;
}

// 定義一個(gè)具有優(yōu)先級(jí)的任務(wù)類
class PriorityTask implements Comparable<PriorityTask>{
    privateint priority;
    private String name;

    public PriorityTask(int priority, String name) {
        this.priority = priority;
        this.name = name;
    }

    @Override
    public int compareTo(PriorityTask o) {
        if (this.priority < o.priority) {
            return -1;
        } elseif (this.priority > o.priority) {
            return1;
        } else {
            return0;
        }
    }

    @Override
    public String toString() {
        return"PriorityTask{" +
                "priority=" + priority +
                ", name='" + name + '\'' +
                '}';
    }
}


publicclass PriorityBlockingQueueExample {

    public static void main(String[] args) throws InterruptedException {
        // 創(chuàng)建一個(gè)優(yōu)先級(jí)阻塞隊(duì)列，使用PriorityTask類的自然順序進(jìn)行排序
        PriorityBlockingQueue<PriorityTask> queue = new PriorityBlockingQueue<>();

        // 添加任務(wù)到隊(duì)列
        queue.put(new PriorityTask(3, "Task 3"));
        queue.put(new PriorityTask(1, "Task 1"));
        queue.put(new PriorityTask(2, "Task 2"));

        // 從隊(duì)列中取出并打印任務(wù)，優(yōu)先級(jí)高的先出隊(duì)
        while (!queue.isEmpty()) {
            PriorityTask task = queue.take();
            System.out.println("Processing: " + task);
        }
    }

}

// 存儲(chǔ)元素的數(shù)組
privatetransient Object[] queue;

// 元素?cái)?shù)量
privatetransientint size;

// 排序規(guī)則（為 null 時(shí)使用自然排序）
privatetransient Comparator<? super E> comparator;

// 保證線程安全的鎖
privatefinal ReentrantLock lock = new ReentrantLock();

// 非空條件變量（用于 take() 阻塞）
privatefinal Condition notEmpty = lock.newCondition();

public boolean offer(E e) {
    if (e == null)
        thrownew NullPointerException();
   // 首先獲取鎖對(duì)象。
    final ReentrantLock lock = this.lock;
   // 只有一個(gè)線程操作入隊(duì)和出隊(duì)動(dòng)作。
    lock.lock();
   // n代表數(shù)組的實(shí)際存儲(chǔ)內(nèi)容的大小
   // cap代表隊(duì)列的整體大小，也就是數(shù)組的長(zhǎng)度。
    int n, cap;
    Object[] array;
   // 如果數(shù)組實(shí)際長(zhǎng)度大于等于數(shù)組的長(zhǎng)度時(shí)，需要進(jìn)行擴(kuò)容操作。
    while ((n = size) >= (cap = (array = queue).length))
        tryGrow(array, cap);
    try {
       // 如果用戶指定比較器，則使用用戶指定的比較器來(lái)進(jìn)行比較，如果沒(méi)有則使用默認(rèn)比較器。
        Comparator<? super E> cmp = comparator;
        if (cmp == null)
           // 進(jìn)行上浮操作。
            siftUpComparable(n, e, array);
        else
           // 進(jìn)行上浮操作。
            siftUpUsingComparator(n, e, array, cmp);
       // 實(shí)際長(zhǎng)度增加1，由于有且僅有一個(gè)線程操作隊(duì)列，所以這里并沒(méi)有使用原子性操作。
        size = n + 1;
       // 通知等待的線程，隊(duì)列已經(jīng)有數(shù)據(jù)，可以獲取數(shù)據(jù)。
        notEmpty.signal();
    } finally {
       // 解鎖操作。
        lock.unlock();
    }
   // 返回操作成功。
    returntrue;
}

public E take() throws InterruptedException {
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly();
    E result;
    try {
        while ( (result = dequeue()) == null)
            notEmpty.await();
    } finally {
        lock.unlock();
    }
    return result;
}

private E dequeue() {
   // 數(shù)組的元素的個(gè)數(shù)。
    int n = size - 1;
   // 如果數(shù)組中不存在元素則直接返回null。
    if (n < 0)
        returnnull;
    else {
       // 獲取隊(duì)列數(shù)組。
        Object[] array = queue;
       // 將第一個(gè)元素也就是二叉堆的根結(jié)點(diǎn)堆頂元素作為返回結(jié)果。
        E result = (E) array[0];
       // 獲取數(shù)組中最后一個(gè)元素。
        E x = (E) array[n];
       // 將最后一個(gè)元素設(shè)置為null。
        array[n] = null;
        Comparator<? super E> cmp = comparator;
        if (cmp == null)
           // 進(jìn)行下沉操作。
            siftDownComparable(0, x, array, n);
        else
           // 進(jìn)行下沉操作。
            siftDownUsingComparator(0, x, array, n, cmp);
       // 實(shí)際元素大小減少1.
        size = n;
       // 返回結(jié)果。
        return result;
    }
}

private finaltransient ReentrantLock lock = new ReentrantLock();
privatefinal PriorityQueue<E> q = new PriorityQueue<E>();//優(yōu)先級(jí)隊(duì)列

public void put(E e) {
    offer(e);
}

public boolean offer(E e) {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        q.offer(e); //插入元素到優(yōu)先級(jí)隊(duì)列
        if (q.peek() == e) { //如果插入的元素在隊(duì)列頭部
            leader = null;
            available.signal(); //通知消費(fèi)線程
        }
        returntrue;
    } finally {
        lock.unlock();
    }
}

public E take() throws InterruptedException {
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly();
    try {
        for (;;) {
            E first = q.peek(); //獲取頭部元素
            if (first == null)
                available.await(); //空隊(duì)列阻塞
            else {
                long delay = first.getDelay(NANOSECONDS); //檢查元素是否延遲到期
                if (delay <= 0)
                    return q.poll(); //到期則彈出元素
                first = null; // don't retain ref while waiting
                if (leader != null)
                    available.await();
                else {
                    Thread thisThread = Thread.currentThread();
                    leader = thisThread;
                    try {
                        available.awaitNanos(delay); //阻塞未到期的時(shí)間
                    } finally {
                        if (leader == thisThread)
                            leader = null;
                    }
                }
            }
        }
    } finally {
        if (leader == null && q.peek() != null)
            available.signal();
        lock.unlock();
    }
}

//非公平情況下調(diào)用內(nèi)部類TransferStack的transfer方法put
public void put(E e) throws InterruptedException {
    if (e == null) thrownew NullPointerException();
    if (transferer.transfer(e, false, 0) == null) {
        Thread.interrupted();
        thrownew InterruptedException();
    }
}
//非公平情況下調(diào)用內(nèi)部類TransferStack的transfer方法take
public E take() throws InterruptedException {
    E e = transferer.transfer(null, false, 0);
    if (e != null)
        return e;
    Thread.interrupted();
    thrownew InterruptedException();
}

//具體的put以及take方法，只有E的區(qū)別，通過(guò)E來(lái)區(qū)別REQUEST還是DATA模式
E transfer(E e, boolean timed, long nanos) {
    SNode s = null; // constructed/reused as needed
    int mode = (e == null) ? REQUEST : DATA;

    for (;;) {
        SNode h = head;
        //棧無(wú)元素或者元素和插入的元素模式相匹配，也就是說(shuō)都是插入元素
        if (h == null || h.mode == mode) {
            //有時(shí)間限制并且超時(shí)
            if (timed && nanos <= 0) {
                if (h != null && h.isCancelled())
                    casHead(h, h.next);  // 重新設(shè)置頭節(jié)點(diǎn)
                else
                    returnnull;
            }
            //未超時(shí)cas操作嘗試設(shè)置頭節(jié)點(diǎn)
            elseif (casHead(h, s = snode(s, e, h, mode))) {
                //自旋一段時(shí)間后未消費(fèi)元素則掛起put線程
                SNode m = awaitFulfill(s, timed, nanos);
                if (m == s) {               // wait was cancelled
                    clean(s);
                    returnnull;
                }
                if ((h = head) != null && h.next == s)
                    casHead(h, s.next);     // help s's fulfiller
                return (E) ((mode == REQUEST) ? m.item : s.item);
            }
        }
        //棧不為空并且和頭節(jié)點(diǎn)模式不匹配，存在元素則消費(fèi)元素并重新設(shè)置head節(jié)點(diǎn)
        elseif (!isFulfilling(h.mode)) { // try to fulfill
            if (h.isCancelled())            // already cancelled
                casHead(h, h.next);         // pop and retry
            elseif (casHead(h, s=snode(s, e, h, FULFILLING|mode))) {
                for (;;) { // loop until matched or waiters disappear
                    SNode m = s.next;       // m is s's match
                    if (m == null) {        // all waiters are gone
                        casHead(s, null);   // pop fulfill node
                        s = null;           // use new node next time
                        break;              // restart main loop
                    }
                    SNode mn = m.next;
                    if (m.tryMatch(s)) {
                        casHead(s, mn);     // pop both s and m
                        return (E) ((mode == REQUEST) ? m.item : s.item);
                    } else                  // lost match
                        s.casNext(m, mn);   // help unlink
                }
            }
        }
        //節(jié)點(diǎn)正在匹配階段
        else {                            // help a fulfiller
            SNode m = h.next;               // m is h's match
            if (m == null)                  // waiter is gone
                casHead(h, null);           // pop fulfilling node
            else {
                SNode mn = m.next;
                if (m.tryMatch(h))          // help match
                    casHead(h, mn);         // pop both h and m
                else                        // lost match
                    h.casNext(m, mn);       // help unlink
            }
        }
    }
}

//先自旋后掛起的核心方法
SNode awaitFulfill(SNode s, boolean timed, long nanos) {
    finallong deadline = timed ? System.nanoTime() + nanos : 0L;
    Thread w = Thread.currentThread();
    //計(jì)算自旋的次數(shù)
    int spins = (shouldSpin(s) ?
                    (timed ? maxTimedSpins : maxUntimedSpins) : 0);
    for (;;) {
        if (w.isInterrupted())
            s.tryCancel();
        SNode m = s.match;
        //匹配成功過(guò)返回節(jié)點(diǎn)
        if (m != null)
            return m;
        //超時(shí)控制
        if (timed) {
            nanos = deadline - System.nanoTime();
            if (nanos <= 0L) {
                s.tryCancel();
                continue;
            }
        }
        //自旋檢查，是否進(jìn)行下一次自旋
        if (spins > 0)
            spins = shouldSpin(s) ? (spins-1) : 0;
        elseif (s.waiter == null)
            s.waiter = w; // establish waiter so can park next iter
        elseif (!timed)
            LockSupport.park(this); //在這里掛起線程
        elseif (nanos > spinForTimeoutThreshold)
            LockSupport.parkNanos(this, nanos);
    }
}