🔗 Java 并发因果链

// ✅ 并行：3个任务同时执行 = 总共1秒 @Autowired private ExecutorService executor; public void parallelExecute() { CompletableFuture.runAsync(() -> queryFromDB(), executor); CompletableFuture.runAsync(() -> callRemoteAPI(), executor); CompletableFuture.runAsync(() -> sendEmail(), executor); // 总耗时：1秒（最慢的那个） }

// ✅ volatile：保证可见性 private volatile boolean stop = false; // volatile 做了两件事： // 1. 写操作：立刻刷新到主内存（不是只写工作内存） // 2. 读操作：每次都从主内存读（不用工作内存的缓存） // 3. 禁止指令重排序（Memory Barrier） // ⚠️ volatile 不保证原子性！ private volatile int count = 0; public void increment() { count++; // ❌ 还是不安全！count++不是原子操作 } // volatile只保证"看到最新值"，不保证"没人同时改"

// 三种用法 // 1. 同步方法（锁的是this对象） public synchronized void increment() { count++; // ✅ 安全 } // 2. 同步静态方法（锁的是Class对象） public static synchronized void staticIncrement() { ... } // 3. 同步代码块（锁指定对象，粒度更细） private final Object lock = new Object(); public void increment() { synchronized (lock) { count++; } } // 底层原理： // - 同步代码块：monitorenter / monitorexit 字节码指令 // - 同步方法：ACC_SYNCHRONIZED 标志位 // - 锁升级：无锁 → 偏向锁 → 轻量级锁(CAS) → 重量级锁(OS互斥)

// ReentrantLock 比 synchronized 多了什么？ ReentrantLock lock = new ReentrantLock(true); // true=公平锁 try { if (lock.tryLock(5, TimeUnit.SECONDS)) { // ✅ 可超时 try { // 业务逻辑 } finally { lock.unlock(); // ✅ 必须手动释放 } } else { log.info("5秒内没拿到锁，走降级逻辑"); // ✅ 可中断 } } catch (InterruptedException e) { Thread.currentThread().interrupt(); } // 因为读操作可以并行 → 所以ReadWriteLock ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock(); rwLock.readLock().lock(); // 多个线程可同时读 rwLock.writeLock().lock(); // 写独占 // 因为读写锁写锁会阻塞所有读 → 所以StampedLock（乐观读） StampedLock stampedLock = new StampedLock(); long stamp = stampedLock.tryOptimisticRead(); // 乐观读，不加锁！ // 读取数据... if (!stampedLock.validate(stamp)) { // 检查期间有没有写 stamp = stampedLock.readLock(); // 有人写了，升级为悲观读锁 try { // 重新读 } finally { stampedLock.unlockRead(stamp); } }

// 线程池核心参数（7个） ThreadPoolExecutor executor = new ThreadPoolExecutor( 10, // corePoolSize: 核心线程数（常驻） 50, // maximumPoolSize: 最大线程数 60, TimeUnit.SECONDS, // keepAliveTime: 非核心线程空闲存活时间 TimeUnit.SECONDS, // 存活时间单位 new LinkedBlockingQueue<>(200), // workQueue: 任务队列 new ThreadFactory() { // threadFactory: 线程工厂 private final AtomicInteger count = new AtomicInteger(1); @Override public Thread newThread(Runnable r) { return new Thread(r, "biz-thread-" + count.getAndIncrement()); } }, new ThreadPoolExecutor.CallerRunsPolicy() // rejectedHandler: 拒绝策略 ); // 任务提交流程（因果链）： // 提交任务 → 核心线程没满？→ 创建核心线程执行 // ↓ 已满 // 队列没满？→ 放入队列等待 // ↓ 已满 // 最大线程没满？→ 创建非核心线程执行 // ↓ 已满 // 执行拒绝策略！

// ✅ CompletableFuture：异步执行，回调处理 CompletableFuture<String> userFuture = CompletableFuture .supplyAsync(() -> queryUser(), executor); CompletableFuture<String> orderFuture = CompletableFuture .supplyAsync(() -> queryOrder(), executor); // 两个都完成后合并 CompletableFuture<String> result = userFuture .thenCombine(orderFuture, (user, order) -> user + " | " + order); // 异常处理 CompletableFuture<String> safeResult = result .exceptionally(ex -> "降级数据"); // 出错时返回默认值 // 典型场景：外卖下单 // 因为下单涉及多个独立操作 → 所以用CF并行执行 CompletableFuture.allOf( CompletableFuture.runAsync(() -> createOrder(), executor), CompletableFuture.runAsync(() -> notifyRestaurant(), executor), CompletableFuture.runAsync(() -> assignRider(), executor) ).join(); // 三个操作并行，1秒内完成

// ThreadLocal 典型场景：用户上下文 public class UserContext { private static final ThreadLocal<User> currentUser = new ThreadLocal<>(); public static void set(User user) { currentUser.set(user); } public static User get() { return currentUser.get(); } public static void clear() { currentUser.remove(); // ⚠️ 必须清理！ } } // 拦截器中设置 @Component public class AuthInterceptor implements HandlerInterceptor { @Override public boolean preHandle(...) { User user = parseToken(request); UserContext.set(user); return true; } @Override public void afterCompletion(...) { UserContext.clear(); // ⚠️ 必须清理！否则内存泄漏 } }