🧵 ThreadLocal · CompletableFuture · 虚拟线程 · AQS Condition

Thread t1 ──> ThreadLocalMap ──> [ Entry(key=ThreadLocalA, value=副本1),
                                          Entry(key=ThreadLocalB, value=副本3) ]
Thread t2 ──> ThreadLocalMap ──> [ Entry(key=ThreadLocalA, value=副本2) ]

// key 是 ThreadLocal 对象（弱引用），value 是业务数据（强引用）
// static final ThreadLocal<User> CTX = new ThreadLocal<>();

// ① 线程池里的线程是「长活」的（不是用完就死）
// ② ThreadLocal 对象本身（比如局部变量）失去强引用 → key 被 GC 置为 null
// ③ 但 Entry 还在 map 里，value 仍被强引用
// ④ 线程不死 → map 不死 → value 永远回收不了 → 内存泄漏

// 线程池复用还会导致「数据串扰」：下一个任务读到了上一个任务的残留值

private static final ThreadLocal<User> CTX = new ThreadLocal<>();

public void handle() {
    CTX.set(currentUser());
    try {
        doSomething();          // 业务逻辑
    } finally {
        CTX.remove();           // ← 这一行是关键，不能省
    }
}

// 需求：查用户 → 用 userId 查订单 → 用订单查物流
CompletableFuture<Logistics> f =
    getUserAsync(uid)                                  // CF<User>
        .thenCompose(u -> getOrderAsync(u.getId()))     // CF<Order>  ← 注意是 compose
        .thenCompose(o -> getLogisticsAsync(o.getId())); // CF<Logistics>

// 如果错用 thenApply，会得到 CF<CF<Order>> 嵌套两层，非常难处理

// 需求：同时查「库存」和「价格」，两个请求互相独立 → 应该并行
CompletableFuture<Stock> fs = supplyAsync(() -> stockService.get(id), pool);
CompletableFuture<Price> fp = supplyAsync(() -> priceService.get(id), pool);

// 两个都完成后合并（总耗时 ≈ max(两者)，不是相加）
CompletableFuture<Detail> detail =
    fs.thenCombine(fp, (s, p) -> new Detail(s, p));

// 批量并行 + 统一收口
CompletableFuture<Void> all = CompletableFuture.allOf(f1, f2, f3);
all.thenRun(() -> System.out.println("三个都完成了"));

CompletableFuture<String> f = supplyAsync(() -> remoteCall(), pool)
    // 兜底：异常时返回默认值，但会「吞掉」异常
    .exceptionally(ex -> "默认值")
    // 更好的写法：handle 同时拿到结果和异常
    .handle((result, ex) -> ex != null ? fallback(ex) : result)
    // 超时控制（JDK 9+）：超时抛 TimeoutException
    .orTimeout(500, TimeUnit.MILLISECONDS)
    // 超时后用默认值继续（JDK 9+）
    .completeOnTimeout("超时默认值", 500, TimeUnit.MILLISECONDS);

// ① 直接启动
Thread.startVirtualThread(() -> System.out.println("跑在虚拟线程上"));

// ② Builder 方式（可以命名，便于排查）
Thread.ofVirtual().name("vt-", 0).start(task);

// ③ 每个任务一个虚拟线程的 Executor（推荐用法）
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    Future<String> f = executor.submit(() -> remoteCall());
    System.out.println(f.get());
}

ReentrantLock lock = new ReentrantLock();
Condition notFull  = lock.newCondition();   // 队列不满的条件
Condition notEmpty = lock.newCondition();   // 队列不空的条件

// 生产者
lock.lock();
try {
    while (queue.size() == MAX) {
        notFull.await();            // 满了：释放锁并等待
    }
    queue.add(item);
    notEmpty.signal();              // 只唤醒「等非空」的消费者
} finally {
    lock.unlock();
}

// Condition 内部维护「条件队列」（单向链表）
ConditionObject ──> firstWaiter ──> Node1 ──> Node2 ──> null

// await()：从同步队列「出来」，进入条件队列
// signal()：把条件队列的头节点「转移」到 AQS 同步队列尾部，等它重新抢锁

// 所以一次 await/signal 涉及两次队列迁移，这也是它比 park/unpark 复杂的地方