// ReentrantLock.NonfairSync.tryAcquire()核心邏輯
final boolean nonfairTryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
        // 鎖空閑，CAS嘗試獲取
        if (compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    else if (current == getExclusiveOwnerThread()) {
        // 同一線程重入，state累加
        int nextc = c + acquires;
        if (nextc < 0) throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    return false;
}

public void lockInterruptibly() throws InterruptedException {
    sync.acquireInterruptibly(1);
}

// AQS.acquireInterruptibly()
public final void acquireInterruptibly(int arg) throws InterruptedException {
    if (Thread.interrupted())
        throw new InterruptedException();
    if (!tryAcquire(arg))
        doAcquireInterruptibly(arg); // 可中斷的等待邏輯
}

// 超時獲取鎖使用示例
public boolean tryLockWithTimeout(ReentrantLock lock, long timeoutMs) {
    try {
        return lock.tryLock(timeoutMs, TimeUnit.MILLISECONDS);
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
        return false;
    }
}

ReentrantLock fairLock = new ReentrantLock(true);    // 公平鎖
ReentrantLock unfairLock = new ReentrantLock(false); // 非公平鎖（默認(rèn)）

/**
 * ReentrantLock完整使用示例
 */
public class ReentrantLockDemo {
    private final ReentrantLock lock = new ReentrantLock(true);
    private final Condition notFull = lock.newCondition();
    private final Condition notEmpty = lock.newCondition();
    private final Queue<Integer> queue = new LinkedList<>();
    private static final int CAPACITY = 10;

    public void produce(int data) throws InterruptedException {
        lock.lock();
        try {
            while (queue.size() == CAPACITY) {
                notFull.await(); // 隊列滿，生產(chǎn)者等待
            }
            queue.offer(data);
            notEmpty.signal(); // 喚醒消費(fèi)者
        } finally {
            lock.unlock(); // 必須在finally中釋放鎖
        }
    }

    public int consume() throws InterruptedException {
        lock.lockInterruptibly(); // 可中斷方式獲取鎖
        try {
            while (queue.isEmpty()) {
                notEmpty.await();
            }
            int data = queue.poll();
            notFull.signal();
            return data;
        } finally {
            lock.unlock();
        }
    }
}

ConcurrentHashMap
└── Segment[] (默認(rèn)16個)
    └── HashEntry[] (每個Segment獨(dú)立的哈希表)
        └── HashEntry鏈表

// JDK8 ConcurrentHashMap.putVal()核心邏輯
final V putVal(K key, V value, boolean onlyIfAbsent) {
    int hash = spread(key.hashCode());
    for (Node<K,V>[] tab = table;;) {
        int i = (n - 1) & hash;
        Node<K,V> f = tabAt(tab, i);
        
        if (f == null) {
            // 桶為空，CAS直接插入
            if (casTabAt(tab, i, null, new Node(hash, key, value)))
                break;
        } else {
            synchronized (f) { // 僅鎖定桶的首節(jié)點
                if (tabAt(tab, i) == f) { // 雙重檢查
                    // 鏈表或紅黑樹插入邏輯
                }
            }
        }
    }
}

// 擴(kuò)容時的ForwardingNode標(biāo)記
static final class ForwardingNode<K,V> extends Node<K,V> {
    final Node<K,V>[] nextTable;
    ForwardingNode(Node<K,V>[] tab) {
        super(MOVED, null, null, null);
        this.nextTable = tab;
    }
}

// ArrayBlockingQueue核心結(jié)構(gòu)
public class ArrayBlockingQueue<E> {
    final Object[] items;      // 存儲數(shù)組
    int takeIndex;             // 取元素位置
    int putIndex;              // 放元素位置
    int count;                 // 元素數(shù)量
    final ReentrantLock lock;  // 單鎖
    private final Condition notEmpty;
    private final Condition notFull;
}

// LinkedBlockingQueue雙鎖設(shè)計
private final ReentrantLock takeLock = new ReentrantLock();
private final Condition notEmpty = takeLock.newCondition();
private final ReentrantLock putLock = new ReentrantLock();
private final Condition notFull = putLock.newCondition();

// SynchronousQueue典型用法
SynchronousQueue<Integer> queue = new SynchronousQueue<>();
// 生產(chǎn)者線程
new Thread(() -> {
    queue.put(1); // 會阻塞直到有消費(fèi)者take
}).start();
// 消費(fèi)者線程
new Thread(() -> {
    queue.take(); // 會阻塞直到有生產(chǎn)者put
}).start();

// 延時任務(wù)元素定義
public class DelayedTask implements Delayed {
    private final long executeTime;
    private final Runnable task;

    public DelayedTask(long delayMs, Runnable task) {
        this.executeTime = System.currentTimeMillis() + delayMs;
        this.task = task;
    }

    @Override
    public long getDelay(TimeUnit unit) {
        return unit.convert(executeTime - System.currentTimeMillis(), TimeUnit.MILLISECONDS);
    }

    @Override
    public int compareTo(Delayed other) {
        return Long.compare(this.executeTime, ((DelayedTask)other).executeTime);
    }
}

// 延時隊列使用示例
DelayQueue<DelayedTask> delayQueue = new DelayQueue<>();
delayQueue.put(new DelayedTask(30000, () -> System.out.println("30秒后執(zhí)行")));
delayQueue.put(new DelayedTask(60000, () -> System.out.println("60秒后執(zhí)行")));

// 消費(fèi)者線程
while (true) {
    DelayedTask task = delayQueue.take(); // 阻塞直到任務(wù)到期
    task.run();
}

// 使用默認(rèn)線程池
CompletableFuture<Void> future1 = CompletableFuture.runAsync(() -> System.out.println("異步任務(wù)"));
CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> "返回結(jié)果");

// 使用自定義線程池（推薦）
ExecutorService executor = Executors.newFixedThreadPool(10);
CompletableFuture<String> future3 = CompletableFuture.supplyAsync(() -> "自定義線程池", executor);

// 手動完成
CompletableFuture<String> future4 = new CompletableFuture<>();
future4.complete("手動設(shè)置結(jié)果");
future4.completeExceptionally(new RuntimeException("手動異常"));

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Hello")
    .thenApply(s -> s + " World")           // 同步轉(zhuǎn)換
    .thenApplyAsync(s -> s.toUpperCase())   // 異步轉(zhuǎn)換
    .thenAccept(s -> System.out.println(s)) // 消費(fèi)結(jié)果
    .thenRun(() -> System.out.println("執(zhí)行完成")); // 僅執(zhí)行，不消費(fèi)結(jié)果

// AND組合：兩個都完成才執(zhí)行
CompletableFuture<String> f1 = CompletableFuture.supplyAsync(() -> "Hello");
CompletableFuture<String> f2 = CompletableFuture.supplyAsync(() -> "World");

f1.thenCombine(f2, (s1, s2) -> s1 + " " + s2)
  .thenAccept(System.out::println); // 輸出 Hello World

// OR組合：任意一個完成就執(zhí)行
CompletableFuture<String> fast = f1.applyToEither(f2, s -> s + " faster");

CompletableFuture.supplyAsync(() -> {
    if (true) throw new RuntimeException("出錯了");
    return "正常";
})
.exceptionally(ex -> {
    System.out.println("捕獲異常: " + ex.getMessage());
    return "默認(rèn)值"; // 異常時返回默認(rèn)值
})
.handle((result, ex) -> {
    if (ex != null) {
        return "處理異常";
    }
    return result;
})
.whenComplete((result, ex) -> {
    // 無論成功失敗都會執(zhí)行，不改變結(jié)果
    System.out.println("執(zhí)行完成");
});

// 所有任務(wù)都完成
CompletableFuture<Void> all = CompletableFuture.allOf(f1, f2, f3);

// 任意一個任務(wù)完成
CompletableFuture<Object> any = CompletableFuture.anyOf(f1, f2, f3);

/**
 * 并行調(diào)用多個服務(wù)，聚合結(jié)果
 */
public class CompletableFutureDemo {
    public UserInfo getUserInfo(Long userId) {
        // 并行調(diào)用三個接口
        CompletableFuture<User> userFuture = CompletableFuture.supplyAsync(() -> userService.getUser(userId));
        CompletableFuture<List<Order>> orderFuture = CompletableFuture.supplyAsync(() -> orderService.getOrders(userId));
        CompletableFuture<List<Address>> addrFuture = CompletableFuture.supplyAsync(() -> addressService.getAddresses(userId));

        // 等待所有完成，聚合結(jié)果
        return CompletableFuture.allOf(userFuture, orderFuture, addrFuture)
            .thenApply(v -> {
                UserInfo info = new UserInfo();
                info.setUser(userFuture.join());
                info.setOrders(orderFuture.join());
                info.setAddresses(addrFuture.join());
                return info;
            })
            .exceptionally(ex -> {
                log.error("獲取用戶信息失敗", ex);
                return null;
            })
            .join();
    }
}