并发进阶

这一课你将能做到

1. 手动创建并优雅关闭一个线程池，背出 ThreadPoolExecutor 七大参数与任务提交流程
2. 用 CompletableFuture 组合多个异步调用（thenCombine / allOf / exceptionally），并解释它与 Future 的区别
3. 说清 volatile、synchronized、AtomicInteger 各自解决什么问题，给共享可变状态选对保护手段

为什么要学

Web 服务天生并发：Tomcat 一个线程处理一个请求，你的接口里再调下游、再算价格，全在共享同一个 JVM。线程池参数拍脑袋、在 Bean 里用普通 int 当计数器、异步链上吞异常——这些在生产环境的表现就是：高峰期线程耗尽、统计数据莫名丢失、接口偶发 500。

面试角度：并发是 Java 面试的最大高地。线程池七参数与拒绝策略、volatile 与 synchronized 的区别、CompletableFuture vs Future、ConcurrentHashMap 原理，几乎每场后端面试都会命中两道以上。本课答案按能背的标准写。

先建立图像

每请求 new Thread          线程池
┌──────────────┐      ┌─────────────────────────────┐
│ 请求1 → T1   │      │ 请求1 ─┐                     │
│ 请求2 → T2   │      │ 请求2 ─┤→ [核心线程×2]        │
│ ...          │      │ ...    ┤→ [阻塞队列等待]      │
│ 请求1万      │      │ 请求N ─┤→ [临时线程(≤max)]    │
│ → 1万线程 💥 │      │ 超限  ─┘→ [拒绝策略]         │
└──────────────┘      └─────────────────────────────┘
  创建销毁 + 上下文        线程复用、任务排队、超限保护
  切换把机器压垮

并发安全的三个层次：

手段	解决什么	代价
不共享（局部变量/不可变对象）	根本没有竞争	无
AtomicInteger / ConcurrentHashMap	单个读改写、容器级安全	CAS 自旋
synchronized / Lock	一段临界区互斥	阻塞、可能锁竞争

跟着做

步骤 1：线程池 + Future 批量汇总

新建 ConcurrencyDemo.java，完整可运行：

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

public class ConcurrencyDemo {

    private static final AtomicInteger okCount = new AtomicInteger();

    /** 模拟调用下游（如查订单金额），耗时 200ms */
    static int fetchAmount(String orderId) {
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return 0;
        }
        okCount.incrementAndGet();
        return Math.abs(orderId.hashCode() % 100) + 100;
    }

    public static void main(String[] args) throws Exception {
        // 生产环境由 Spring 托管池；这里手动 new 是为了看清每个参数
        ExecutorService pool = new ThreadPoolExecutor(
                2, 4, 60, TimeUnit.SECONDS,          // 核心2、上限4、空闲60s回收
                new ArrayBlockingQueue<>(100),        // 有界队列
                r -> new Thread(r, "demo-worker"),    // 命名线程，排查日志靠它
                new ThreadPoolExecutor.CallerRunsPolicy()); // 拒绝策略

        List<Future<Integer>> futures = new ArrayList<>();
        for (int i = 1; i <= 4; i++) {
            String orderId = "order-" + i;
            futures.add(pool.submit(() -> fetchAmount(orderId)));
        }
        int total = 0;
        for (Future<Integer> f : futures) {
            total += f.get(); // Future.get 阻塞等待结果
        }
        System.out.println("订单总额=" + total + "，成功次数=" + okCount.get());

        pool.shutdown();
        pool.awaitTermination(10, TimeUnit.SECONDS);
    }
}