☕ Java并发编程图解

public class SynchronizedLockUpgrade { // 对象头 Mark Word 结构（64位JVM） // |---------------------------------------------| // | 无锁: unused(25) | hashcode(31) | unused(1) | age(4) | 0(1) | 01(2) | // | 偏向锁: threadID(54) | epoch(2) | unused(1) | age(4) | 1(1) | 01(2) | // | 轻量锁: 指向栈中Lock Record的指针(62) | 00(2) | // | 重量锁: 指向Monitor对象的指针(62) | 10(2) | // |---------------------------------------------| private static Object lock = new Object(); public static void main(String[] args) throws Exception { // Step1: 无锁状态 — 对象刚创建 System.out.println(ClassLayout.parseInstance(lock).toPrintable()); // Step2: 偏向锁 — 只有一个线程反复进入 synchronized (lock) { System.out.println(ClassLayout.parseInstance(lock).toPrintable()); // Mark Word = 101 (偏向锁标志位) } // Step3: 轻量锁 — 第二个线程竞争 Thread t1 = new Thread(() -> { synchronized (lock) { System.out.println("t1持有锁"); } }); t1.start(); t1.join(); // Step4: 重量锁 — 自旋失败后膨胀 for (int i = 0; i < 100; i++) { new Thread(() -> { synchronized (lock) { // 大量竞争 → 重量锁 } }).start(); } } }

public class VolatileVisibility { // ❌ 没有 volatile — 程序永远不会停止！ private static boolean running = true; // ✅ 有 volatile — 主线程改了，子线程立即看到 private static volatile boolean runningV = true; public static void main(String[] args) throws Exception { // ✅ volatile版本：1秒后正常停止 Thread reader = new Thread(() -> { int count = 0; while (runningV) { // 每次都从主内存读 count++; } System.out.println("读线程停止，共循环 " + count); }); reader.start(); Thread.sleep(1000); runningV = false; // 写入主内存 + StoreLoad屏障 // reader线程会立即感知到 runningV == false reader.join(); } } // ⚡ DCL单例为什么要volatile？ class Singleton { private static volatile Singleton INSTANCE; // ← 必须volatile! public static Singleton getInstance() { if (INSTANCE == null) { // 1.第一次检查 synchronized (Singleton.class) { // 2.加锁 if (INSTANCE == null) { // 3.第二次检查 INSTANCE = new Singleton(); // 4.创建对象 // ⚠️ new不是原子操作！分3步: // ① 分配内存空间 // ② 初始化对象 // ③ 引用指向内存地址 // 没volatile: ②③可能重排 → 别人拿到未初始化的对象! } } } return INSTANCE; } }

// ThreadPoolExecutor 7大参数详解 ThreadPoolExecutor pool = new ThreadPoolExecutor( 5, // ① corePoolSize: 核心线程数（常驻线程） 10, // ② maximumPoolSize: 最大线程数（正式+临时） 60, TimeUnit.SECONDS, // ③ keepAliveTime: 临时线程空闲多久后回收 new LinkedBlockingQueue(<>100), // ④ workQueue: 任务队列(容量100) Executors.defaultThreadFactory(), // ⑤ threadFactory: 创建线程的工厂 new ThreadPoolExecutor.CallerRunsPolicy() // ⑥ handler: 拒绝策略 ); // ⚠️ 阿里巴巴规范：不要用Executors创建线程池！ // Executors.newFixedThreadPool() → 队列无界 → OOM! // Executors.newCachedThreadPool() → 最大线程=Integer.MAX_VALUE → OOM! // ✅ 手动创建，明确指定每个参数 // 💡 线程数怎么定？ // CPU密集型: corePoolSize = CPU核数 + 1 // IO密集型: corePoolSize = CPU核数 * 2 (或 CPU核数 / (1-阻塞系数)) int cpuCores = Runtime.getRuntime().availableProcessors(); System.out.println("当前CPU核数: " + cpuCores);

// AQS 核心源码简化版 (java.util.concurrent.locks.AbstractQueuedSynchronizer) public abstract class AbstractQueuedSynchronizer { private volatile int state; // 同步状态（核心！） private volatile Node head; // CLH队列头 private volatile Node tail; // CLH队列尾 private transient volatile Thread exclusiveOwnerThread; // 独占线程 // 加锁核心：tryAcquire (子类实现) protected boolean tryAcquire(int arg) { int c = getState(); if (c == 0) { // state=0 → 无人持有 if (compareAndSetState(0, arg)) { // CAS抢锁 setExclusiveOwnerThread(Thread.currentThread()); return true; } } else if (Thread.currentThread() == getExclusiveOwnerThread()) { setState(c + arg); // 重入: state+1 return true; } return false; } // 解锁核心：tryRelease protected boolean tryRelease(int arg) { int c = getState() - arg; if (Thread.currentThread() != getExclusiveOwnerThread()) throw new IllegalMonitorStateException(); boolean free = false; if (c == 0) { // state减到0才算释放 free = true; setExclusiveOwnerThread(null); } setState(c); return free; } }

// ① CountDownLatch: 主线程等所有子任务完成 CountDownLatch latch = new CountDownLatch(3); // 3个子任务 for (int i = 0; i < 3; i++) { new Thread(() -> { try { Thread.sleep(1000); } catch (InterruptedException e) {} System.out.println(Thread.currentThread().getName() + " 完成"); latch.countDown(); // 计数-1 }).start(); } latch.await(); // 主线程等计数归0 System.out.println("所有子任务完成，开始汇总！"); // ② CyclicBarrier: 线程间互相等待 CyclicBarrier barrier = new CyclicBarrier(3, () -> { System.out.println("=== 所有人到齐，出发！ ==="); // 到齐后自动执行 }); for (int i = 0; i < 3; i++) { new Thread(() -> { System.out.println(Thread.currentThread().getName() + " 到了"); barrier.await(); // 等其他人到齐 System.out.println(Thread.currentThread().getName() + " 出发"); }).start(); } // ③ Semaphore: 控制并发访问数 Semaphore semaphore = new Semaphore(3); // 最多3个线程同时执行 for (int i = 0; i < 10; i++) { new Thread(() -> { try { semaphore.acquire(); // 拿车位牌 System.out.println(Thread.currentThread().getName() + " 停车"); Thread.sleep(2000); } finally { semaphore.release(); // 还车位牌 } }).start(); }

public class ThreadLifecycleDemo { public static void main(String[] args) throws Exception { Object lock = new Object(); Thread t1 = new Thread(() -> { synchronized (lock) { try { System.out.println("t1: 我在wait了..."); lock.wait(); // → 进入WAITING，释放lock // lock.wait(3000); → 进入TIMED_WAITING System.out.println("t1: 被唤醒了！"); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } } }, "等待线程"); Thread t2 = new Thread(() -> { synchronized (lock) { // t1在wait，t2拿到了lock → t1在WAITING System.out.println("t2: 我拿到锁了，3秒后唤醒t1"); try { Thread.sleep(3000); } // → TIMED_WAITING catch (InterruptedException e) {} lock.notify(); // 唤醒t1 → t1进入BLOCKED(等t2释放锁) // t2退出synchronized → t1获得锁 → RUNNABLE } }, "通知线程"); // 状态转换: NEW → start() → RUNNABLE → wait() → WAITING // → notify() → BLOCKED → 获锁 → RUNNABLE → run()结束 → TERMINATED System.out.println("t1状态: " + t1.getState()); // NEW t1.start(); Thread.sleep(100); System.out.println("t1状态: " + t1.getState()); // WAITING } }

// ✅ 生产场景1：用户上下文传递（最常见！） 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(); } // ⚠️ 必须！ } // 拦截器：请求进来时设置用户，请求结束时清理 public class AuthInterceptor implements HandlerInterceptor { @Override public boolean preHandle(HttpServletRequest req, ...) { User user = parseToken(req.getHeader("Authorization")); UserContext.set(user); // ← Thread-1设"张三", Thread-2设"李四" return true; } @Override public void afterCompletion(...) { UserContext.clear(); // ⚠️ 必须！否则线程池复用→脏数据+内存泄漏 } } // 任何地方都能拿到当前用户，不用层层传参！ public class OrderService { public void createOrder(OrderDTO dto) { User user = UserContext.get(); // 直接拿，不用传参 order.setUserId(user.getId()); orderDao.save(order); } }

// ✅ 生产场景2：SimpleDateFormat线程安全 // ❌ SimpleDateFormat不是线程安全的！多线程共享会出错 // private static final SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); // ↑ 多线程并发调用sdf.parse() → 数据错乱! // ✅ 用ThreadLocal：每个线程一份，各用各的 public class DateUtils { private static final ThreadLocal<SimpleDateFormat> sdf = ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyy-MM-dd")); public static Date parse(String dateStr) throws ParseException { return sdf.get().parse(dateStr); // 每个线程拿到自己的实例 } public static String format(Date date) { return sdf.get().format(date); } } // ⚠️ JDK 8+ 更推荐 DateTimeFormatter（天然线程安全） private static final DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd"); // ↑ DateTimeFormatter是不可变对象，天生线程安全，不需要ThreadLocal

// ⚠️ 内存泄漏演示：线程池 + ThreadLocal = 重灾区！ public class ThreadLocalLeakDemo { private static final ThreadLocal<byte[]> threadLocal = new ThreadLocal<>(); public static void main(String[] args) { ExecutorService pool = Executors.newFixedThreadPool(5); for (int i = 0; i < 100; i++) { pool.submit(() -> { // ❌ 每次都set一个1MB的数组，但从不remove threadLocal.set(new byte[1024 * 1024]); // 1MB // ... 业务逻辑 ... // ❌ 忘了 remove()！ // 线程池的线程被复用，ThreadLocalMap一直存在 // → 100次 × 1MB = 100MB 泄漏！ }); } // ✅ 正确写法：必须在 finally 中 remove pool.submit(() -> { try { threadLocal.set(new byte[1024 * 1024]); // ... 业务逻辑 ... } finally { threadLocal.remove(); // ← 绝对不能忘！ } }); } } // 💡 泄漏原理： // ThreadLocalMap.Entry extends WeakReference<ThreadLocal<?>> // → Key是弱引用（GC会回收），Value是强引用（GC不会回收） // → Key被GC回收变成null，但Value还被Entry引用着 // → 这个null→Value的Entry永远无法被访问到，也永远无法被GC回收 // → 这就是泄漏！ // // 💡 为什么用WeakReference还要泄漏？ // WeakReference只保证"ThreadLocal对象本身"能被回收 // 但Value不是WeakReference！Value是强引用！ // → ThreadLocal对象被回收了，但Value还在Map里占着内存