知序
返回
保存草稿
发布
H1
H2
H3
1
2
3
Excalidraw 图
AI 写作
AI 优化
目录
输入内容后显示目录
Markdown
# Java JUC 并发编程深度解析 > java.util.concurrent 核心原理与面试指南 --- ## 目录 1. [线程基础](#1-线程基础) 2. [synchronized 深入](#2-synchronized-深入) 3. [volatile](#3-volatile) 4. [ReentrantLock](#4-reentrantlock) 5. [AQS 原理](#5-aqs-原理) 6. [并发工具类](#6-并发工具类) 7. [原子类](#7-原子类) 8. [线程池](#8-线程池) 9. [并发集合](#9-并发集合) 10. [ThreadLocal](#10-threadlocal) 11. [JMM 与 happens-before](#11-jmm-与-happens-before) 12. [CompletableFuture](#12-completablefuture) 13. [读写锁与死锁排查](#13-读写锁与死锁排查) 14. [Fork/Join](#14-forkjoin) 15. [伪共享与性能优化](#15-伪共享与性能优化) 16. [如何优雅停止线程](#16-如何优雅停止线程) 17. [面试高频 Q&A](#17-面试高频-qa) --- ## 1. 线程基础 ### Thread vs Runnable vs Callable ```java // Thread:继承,单继承限制 class MyThread extends Thread { public void run() { System.out.println("Thread"); } } // Runnable:实现接口,无返回值,无法抛受检异常 class MyRunnable implements Runnable { public void run() { System.out.println("Runnable"); } } // Callable:有返回值,可抛受检异常,配合 Future 使用 class MyCallable implements Callable<String> { public String call() throws Exception { return "Callable"; } } // Callable 的使用 ExecutorService executor = Executors.newSingleThreadExecutor(); Future<String> future = executor.submit(new MyCallable()); String result = future.get(); // 阻塞等待结果 ``` ### 线程的 6 种状态 ``` NEW(新建) ↓ start() RUNNABLE(可运行/运行中) ↓ synchronized 获取锁失败 BLOCKED(阻塞,等待锁) ↓ wait() / join() / LockSupport.park() WAITING(无限期等待) ↓ wait(timeout) / sleep(timeout) / join(timeout) TIMED_WAITING(有限期等待) ↓ 线程执行完毕 TERMINATED(终止) BLOCKED vs WAITING: BLOCKED:等待 synchronized 锁,由 JVM 调度 WAITING:主动放弃 CPU,等待其他线程唤醒(notify/interrupt) ``` ### sleep vs wait vs yield vs join ```java // sleep:Thread 的静态方法,让当前线程睡眠,不释放锁 Thread.sleep(1000); // wait:Object 的方法,必须在 synchronized 块中调用,释放锁,等待 notify 唤醒 synchronized (lock) { lock.wait(); // 释放 lock,进入 WAITING lock.wait(1000); // 超时自动唤醒 } // yield:让出 CPU 时间片,但不释放锁,可能立即再次被调度 Thread.yield(); // join:等待指定线程执行完毕 Thread t = new Thread(() -> { ... }); t.start(); t.join(); // 当前线程阻塞,直到 t 执行完毕 ``` --- ## 2. synchronized 深入 ### 对象锁 vs 类锁 ```java public class Demo { // 对象锁:锁的是 this 实例 public synchronized void instanceMethod() { ... } // 等价于 public void instanceMethod() { synchronized (this) { ... } } // 类锁:锁的是 Demo.class 对象(全局唯一) public static synchronized void staticMethod() { ... } // 等价于 public static void staticMethod() { synchronized (Demo.class) { ... } } } // 对象锁和类锁互不影响,可以同时被不同线程持有 ``` ### 锁升级过程(面试高频) ``` 无锁 → 偏向锁 → 轻量级锁 → 重量级锁 (单线程) (短暂竞争) (激烈竞争) 锁信息存储在对象头的 Mark Word(64位JVM,8字节)中: 无锁状态: [hashcode(31) | age(4) | biased(1)=0 | 01] 偏向锁(只有一个线程访问): [threadId(54) | epoch(2) | age(4) | biased(1)=1 | 01] 第一个线程获取锁时,将线程ID写入 Mark Word 后续该线程进入无需 CAS,只检查线程ID 轻量级锁(多线程交替访问,无竞争): [指向栈中锁记录的指针(62) | 00] 线程在栈帧中创建 Lock Record,CAS 将 Mark Word 替换为指向 Lock Record 的指针 CAS 失败说明有竞争,膨胀为重量级锁 重量级锁(多线程同时竞争): [指向 Monitor 的指针(62) | 10] 基于 OS 的 Mutex Lock,涉及用户态→内核态切换,性能开销大 ``` ``` 锁升级是单向的,不能降级(偏向锁可以撤销) JDK 15 起偏向锁被废弃(维护成本高,现代多核场景收益有限) JDK 18 完全移除偏向锁 ``` --- ## 3. volatile ### 两个保证 ``` 1. 可见性:写操作立即刷新到主内存,读操作从主内存读取最新值 → 解决:一个线程修改变量,其他线程看不到的问题 2. 有序性:禁止指令重排序(通过内存屏障实现) → 解决:DCL 单例中 instance = new Singleton() 的重排序问题 不保证:原子性(i++ 仍然不是原子操作) ``` ### 内存屏障 ``` volatile 写操作: StoreStore 屏障(写之前) volatile 写 StoreLoad 屏障(写之后,最重要,防止后续读操作重排到写之前) volatile 读操作: volatile 读 LoadLoad 屏障(读之后) LoadStore 屏障(读之后) ``` ### 典型使用场景 ```java // 场景1:状态标志(可见性) public class Server { private volatile boolean running = true; public void stop() { running = false; } public void run() { while (running) { // 能看到 running 的最新值 processRequest(); } } } // 场景2:DCL 单例(有序性) public class Singleton { private static volatile Singleton instance; // 必须加 volatile public static Singleton getInstance() { if (instance == null) { synchronized (Singleton.class) { if (instance == null) { instance = new Singleton(); // 没有 volatile:可能重排为:分配内存→指向地址→初始化对象 // 其他线程看到 instance != null 但对象未初始化完成 } } } return instance; } } ``` --- ## 4. ReentrantLock ### vs synchronized | 特性 | synchronized | ReentrantLock | |------|-------------|---------------| | 实现层面 | JVM 内置 | Java 代码(AQS) | | 锁释放 | 自动(代码块结束/异常) | 手动(必须 finally unlock) | | 可中断 | 不可中断 | `lockInterruptibly()` 可中断 | | 超时获取 | 不支持 | `tryLock(timeout)` | | 公平锁 | 不支持 | 支持(`new ReentrantLock(true)`) | | 条件变量 | 一个(wait/notify) | 多个(Condition) | | 性能 | JDK 6+ 优化后相近 | 相近 | ```java ReentrantLock lock = new ReentrantLock(); // 基本用法(必须在 finally 中 unlock) lock.lock(); try { // 临界区 } finally { lock.unlock(); } // 可中断获取锁 lock.lockInterruptibly(); // 超时获取锁 if (lock.tryLock(3, TimeUnit.SECONDS)) { try { ... } finally { lock.unlock(); } } else { System.out.println("获取锁超时"); } ``` ### Condition 精确唤醒 ```java ReentrantLock lock = new ReentrantLock(); Condition notFull = lock.newCondition(); // 队列不满 Condition notEmpty = lock.newCondition(); // 队列不空 // 生产者 lock.lock(); try { while (queue.isFull()) notFull.await(); // 等待"不满"信号 queue.add(item); notEmpty.signal(); // 精确唤醒消费者(不唤醒生产者) } finally { lock.unlock(); } // 消费者 lock.lock(); try { while (queue.isEmpty()) notEmpty.await(); // 等待"不空"信号 queue.poll(); notFull.signal(); // 精确唤醒生产者 } finally { lock.unlock(); } ``` --- ## 5. AQS 原理 AQS(AbstractQueuedSynchronizer)是 JUC 中大多数同步器的基础框架。 ### 核心结构 ```java public abstract class AbstractQueuedSynchronizer { // 同步状态(volatile) private volatile int state; // CLH 队列(双向链表,存放等待线程) private transient volatile Node head; private transient volatile Node tail; static final class Node { volatile int waitStatus; // 节点状态 volatile Node prev; volatile Node next; volatile Thread thread; // 等待的线程 } } ``` ### 工作原理 ``` 独占模式(ReentrantLock): acquire(1): 1. tryAcquire(1):CAS 将 state 从 0 改为 1(获取锁) 2. 失败则将当前线程封装为 Node 加入 CLH 队列尾部 3. 自旋等待,前驱节点是 head 时再次尝试 tryAcquire 4. 失败则 LockSupport.park() 挂起线程 release(1): 1. tryRelease(1):将 state 减 1(释放锁) 2. state == 0 时唤醒 CLH 队列中的第一个等待线程(LockSupport.unpark) 共享模式(Semaphore/CountDownLatch): acquireShared(n):允许多个线程同时获取 releaseShared(n):释放后唤醒所有等待线程 ``` ### 基于 AQS 的实现 ``` ReentrantLock: state = 0:未锁定 state = 1:锁定(可重入时 state > 1) tryAcquire:CAS(0 → 1) 或 state+1(重入) Semaphore: state = 许可证数量 tryAcquireShared:state - n(CAS) tryReleaseShared:state + n(CAS) CountDownLatch: state = 计数值 countDown():state - 1(CAS) await():state == 0 时返回,否则阻塞 ReentrantReadWriteLock: state 高16位:读锁计数 state 低16位:写锁计数 ``` --- ## 6. 并发工具类 ### CountDownLatch(倒计时门闩) ```java // 场景:主线程等待多个子线程完成后再继续 CountDownLatch latch = new CountDownLatch(3); // 计数器初始值 3 // 子线程 for (int i = 0; i < 3; i++) { new Thread(() -> { try { doWork(); } finally { latch.countDown(); // 计数器 -1 } }).start(); } latch.await(); // 主线程阻塞,直到计数器为 0 System.out.println("所有子线程完成"); // 注意:CountDownLatch 不可重用,计数到0后无法重置 ``` ### CyclicBarrier(循环屏障) ```java // 场景:多个线程互相等待,都到达屏障点后一起继续 CyclicBarrier barrier = new CyclicBarrier(3, () -> { System.out.println("所有线程到达屏障,开始下一阶段"); // 屏障动作 }); for (int i = 0; i < 3; i++) { new Thread(() -> { doPhase1(); barrier.await(); // 等待其他线程到达 doPhase2(); // 所有线程同时开始第二阶段 }).start(); } // CyclicBarrier 可以重用(reset() 或自动重置) ``` **CountDownLatch vs CyclicBarrier:** - CountDownLatch:一次性,一个线程等多个线程(或多个线程等一个信号) - CyclicBarrier:可重用,多个线程互相等待,到齐后一起继续 ### Semaphore(信号量) ```java // 场景:限制并发访问数量(如数据库连接池、限流) Semaphore semaphore = new Semaphore(5); // 最多5个线程同时访问 void accessResource() throws InterruptedException { semaphore.acquire(); // 获取许可(没有许可则阻塞) try { doWork(); } finally { semaphore.release(); // 释放许可 } } // 公平模式(按等待顺序分配许可) Semaphore fairSemaphore = new Semaphore(5, true); ``` --- ## 7. 原子类 ### AtomicInteger / AtomicLong ```java AtomicInteger count = new AtomicInteger(0); count.get(); // 读取 count.set(10); // 设置 count.getAndIncrement(); // i++(返回旧值) count.incrementAndGet(); // ++i(返回新值) count.addAndGet(5); // += 5(返回新值) count.compareAndSet(10, 20); // CAS:期望值10,新值20 ``` ### CAS 原理与 ABA 问题 ``` CAS(Compare And Swap): 比较内存中的值是否等于期望值,是则更新为新值,否则重试 底层是 CPU 的原子指令(LOCK CMPXCHG) ABA 问题: 线程1 读到 value = A 线程2 将 value 改为 B,再改回 A 线程1 CAS 成功(值还是 A),但中间发生了变化 解决:AtomicStampedReference(带版本号) ``` ```java // AtomicStampedReference 解决 ABA AtomicStampedReference<Integer> ref = new AtomicStampedReference<>(1, 0); int[] stampHolder = new int[1]; int value = ref.get(stampHolder); // 获取值和版本号 int stamp = stampHolder[0]; // CAS 时同时检查版本号 ref.compareAndSet(value, newValue, stamp, stamp + 1); ``` ### LongAdder vs AtomicLong ``` AtomicLong 的问题: 高并发时,多个线程同时 CAS 同一个变量,大量失败重试,CPU 浪费 LongAdder 的解决方案:分段累加 维护一个 base 值 + Cell[] 数组 低竞争时:直接 CAS 更新 base 高竞争时:每个线程更新自己对应的 Cell(减少竞争) 读取时:sum = base + Σ Cell[i] 代价:sum() 不是实时精确值(并发写入时) 适合:写多读少的统计场景(如 QPS、PV 统计) ``` --- ## 8. 线程池 ### ThreadPoolExecutor 7 个核心参数 ```java ThreadPoolExecutor executor = new ThreadPoolExecutor( 5, // corePoolSize:核心线程数(常驻) 10, // maximumPoolSize:最大线程数 60L, // keepAliveTime:非核心线程空闲存活时间 TimeUnit.SECONDS, // 时间单位 new ArrayBlockingQueue<>(100), // workQueue:任务队列 Executors.defaultThreadFactory(), // threadFactory:线程工厂 new ThreadPoolExecutor.AbortPolicy() // handler:拒绝策略 ); ``` ### 工作流程 ``` 提交任务 ↓ 当前线程数 < corePoolSize? 是 → 创建核心线程执行 否 ↓ 任务队列未满? 是 → 任务放入队列 否 ↓ 当前线程数 < maximumPoolSize? 是 → 创建非核心线程执行 否 → 执行拒绝策略 ``` ### 4 种拒绝策略 ```java AbortPolicy(默认):抛出 RejectedExecutionException CallerRunsPolicy:由提交任务的线程自己执行(降速,不丢任务) DiscardPolicy:静默丢弃,不抛异常 DiscardOldestPolicy:丢弃队列中最老的任务,重新提交当前任务 // 生产推荐:自定义拒绝策略(记录日志+告警) executor.setRejectedExecutionHandler((r, pool) -> { log.error("线程池拒绝任务,队列大小: {}", pool.getQueue().size()); // 写入数据库或消息队列,后续重试 }); ``` ### 为什么不推荐 Executors 创建线程池? ``` newFixedThreadPool / newSingleThreadExecutor: 使用无界队列 LinkedBlockingQueue(Integer.MAX_VALUE) 任务堆积可能导致 OOM newCachedThreadPool: 最大线程数为 Integer.MAX_VALUE 可能创建大量线程导致 OOM 推荐:直接用 ThreadPoolExecutor,明确指定所有参数 ``` ### 线程数如何配置? ``` CPU 密集型(计算、加密、压缩): 线程数 = CPU 核数 + 1 多一个线程是为了防止某个线程偶尔阻塞时 CPU 空闲 I/O 密集型(数据库、网络请求、文件读写): 线程数 = CPU 核数 × (1 + 等待时间/计算时间) 等待时间远大于计算时间时,可以设置更多线程 经验值:CPU 核数 × 2 实际生产:通过压测确定最优线程数,监控队列大小和拒绝次数 ``` --- ## 9. 并发集合 ### ConcurrentHashMap(JDK 8) ``` JDK 7:分段锁(Segment),最多16个线程并发写 JDK 8:CAS + synchronized,锁粒度更细 put 流程: 桶为空 → CAS 直接插入(无锁) 桶不为空 → synchronized 锁住桶的头节点 正在扩容 → 帮助迁移数据(helpTransfer) size 统计: 使用 CounterCell 数组分散计数(LongAdder 思想) 避免高并发下 size++ 的竞争 读操作: Node 的 val 和 next 字段用 volatile 修饰 get() 无需加锁,性能极高 ``` ### CopyOnWriteArrayList ```java // 写时复制:写操作时复制整个数组,写完后替换引用 // 读操作无锁,写操作加锁 CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>(); list.add("a"); // 复制数组,在新数组上添加,替换引用 // 适用场景:读多写少(如配置列表、白名单) // 缺点:写操作 O(n),内存占用翻倍,不适合频繁写入 ``` ### BlockingQueue 家族 ```java // LinkedBlockingQueue:链表,可选有界,生产消费分离锁(吞吐量高) BlockingQueue<String> queue = new LinkedBlockingQueue<>(100); // ArrayBlockingQueue:数组,有界,生产消费共用一把锁 BlockingQueue<String> queue = new ArrayBlockingQueue<>(100); // SynchronousQueue:容量为0,每次 put 必须等待 take(直接传递) BlockingQueue<String> queue = new SynchronousQueue<>(); // 阻塞操作 queue.put("task"); // 队满时阻塞 queue.take(); // 队空时阻塞 queue.offer("task", 1, TimeUnit.SECONDS); // 超时返回 false queue.poll(1, TimeUnit.SECONDS); // 超时返回 null ``` --- ## 10. ThreadLocal ### 原理 ``` 每个 Thread 对象内部有一个 ThreadLocalMap: Thread.threadLocals = new ThreadLocalMap() ThreadLocalMap 的 Entry: static class Entry extends WeakReference<ThreadLocal<?>> { Object value; // 强引用 Entry(ThreadLocal<?> k, Object v) { super(k); // key 是弱引用 value = v; } } set(value): Thread.currentThread().threadLocals.set(this, value) 以当前 ThreadLocal 对象为 key,value 为值 get(): Thread.currentThread().threadLocals.get(this) ``` ### 内存泄漏问题 ``` ThreadLocalMap 的 Entry: ThreadLocal<User> threadlocal,此时key是threadlocal,值是该user对象 key(ThreadLocal 对象):弱引用 → GC 时会被回收,变为 null value(实际数据):强引用 → key 为 null 后,value 无法被访问也无法被回收 内存泄漏场景: 线程池中的线程不会销毁 ThreadLocal 对象被 GC 回收(key = null) 但 value 仍然被 Entry 强引用,无法回收 → 内存泄漏! 解决:使用完 ThreadLocal 后必须调用 remove() ``` ```java // 正确使用方式 private static final ThreadLocal<SimpleDateFormat> dateFormat = ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyy-MM-dd")); public String formatDate(Date date) { try { return dateFormat.get().format(date); } finally { dateFormat.remove(); // 必须清理! } } ``` ### InheritableThreadLocal ```java // 子线程可以继承父线程的 ThreadLocal 值 InheritableThreadLocal<String> itl = new InheritableThreadLocal<>(); itl.set("parent value"); new Thread(() -> { System.out.println(itl.get()); // 输出:parent value }).start(); // 注意:线程池中线程复用,InheritableThreadLocal 可能传递错误的值 // 推荐使用 TransmittableThreadLocal(阿里开源)解决线程池场景 ``` --- ## 11. JMM 与 happens-before ### Java 内存模型(JMM) ``` JMM 不是具体实现,而是一套并发内存访问规范,主要回答 3 个问题: 1. 可见性:一个线程修改共享变量后,其他线程什么时候能看到 2. 有序性:编译器和 CPU 能不能重排序 3. 原子性:哪些操作天然不可分割,哪些需要额外同步手段 ``` ``` 线程工作时并不是每次都直接操作主内存: 主内存 ↑ ↓ 工作内存A 工作内存B 线程先把共享变量读到自己的工作内存里,计算后再刷回主内存。 如果没有同步手段,就可能出现: 线程 A 已经改了值 线程 B 还读到旧值 ``` ### happens-before 规则 ``` happens-before 可以理解成“前一个操作的结果,对后一个操作可见,并且执行顺序被约束”。 高频规则: 1. 程序次序规则:同一线程内,前面的代码先行发生于后面的代码 2. 锁规则:解锁 happens-before 后续对同一把锁的加锁 3. volatile 规则:对 volatile 变量的写 happens-before 后续对它的读 4. 传递性:如果 A happens-before B,B happens-before C,那么 A happens-before C 5. 线程启动规则:Thread.start() happens-before 子线程中的动作 6. 线程终止规则:子线程中的所有操作 happens-before 其他线程检测到它结束 7. 中断规则:interrupt() happens-before 被中断线程感知到中断 ``` ### 为什么它面试里高频 ``` 因为 volatile、synchronized、Thread.start/join、线程池上下文可见性,本质上都能往 happens-before 这套规则上落。 如果你能把“现象”翻译成“可见性和有序性约束”,回答会更稳。 ``` --- ## 12. CompletableFuture ### 核心价值 ``` CompletableFuture = 异步执行 + 结果编排 + 异常处理 它比传统 Future 更强的地方在于: 1. Future 只能阻塞 get 2. CompletableFuture 可以把多个异步任务串起来、合起来、兜底处理 ``` ### 常见用法 ```java CompletableFuture<String> userFuture = CompletableFuture.supplyAsync(() -> loadUser()); CompletableFuture<String> orderFuture = CompletableFuture.supplyAsync(() -> loadOrder()); CompletableFuture<String> resultFuture = userFuture.thenCombine(orderFuture, (user, order) -> user + ":" + order) .exceptionally(ex -> "fallback"); String result = resultFuture.join(); ``` ### 高频 API ``` thenApply :拿到上一步结果,继续做转换 thenAccept :消费结果,不返回新值 thenRun :不关心结果,只关心后续动作 thenCompose :串联两个异步任务,避免 Future 嵌套 thenCombine :合并两个异步结果 allOf :等多个任务都完成 anyOf :任意一个完成就继续 exceptionally :异常兜底 handle :统一处理正常结果和异常 ``` ### 使用注意点 ``` 1. 不要默认依赖公共线程池做重任务,最好显式传入业务线程池 2. join() 会把受检异常包装成 CompletionException 3. thenApply 和 thenApplyAsync 的执行线程可能不同,面试里经常追问 ``` --- ## 13. 读写锁与死锁排查 ### ReentrantReadWriteLock ``` 读锁共享,写锁互斥: 读-读:可以并发 读-写:互斥 写-写:互斥 ``` ``` 适用场景: 1. 读多写少 2. 数据结构读操作频繁 3. 写操作相对少,但仍然需要强一致互斥 不适合: 1. 写很多 2. 锁竞争本来就重 3. 临界区很短,读写锁收益抵不过管理开销 ``` ### 什么是死锁 ``` 死锁 = 多个线程互相等待对方持有的资源,最终谁都走不下去。 典型例子: 线程 A 先拿锁 1,再等锁 2 线程 B 先拿锁 2,再等锁 1 ``` ### 排查和预防 ``` 排查: 1. jstack 看线程栈 2. jconsole / visualvm / arthas 看线程阻塞关系 3. 关注是否都卡在 synchronized 或 lock() 预防: 1. 统一加锁顺序 2. 减少锁嵌套 3. 避免持锁时做远程调用或长时间阻塞 4. 必要时用 tryLock(timeout) 避免无限等待 ``` --- ## 14. Fork/Join ### 分治模型 ``` Fork/Join 适合“一个大任务可以不断拆成小任务,再把结果汇总”的场景。 流程: 大任务 → fork 拆分子任务 → 子任务并行执行 → join 合并结果 ``` ### 工作窃取 ``` 每个工作线程都有自己的双端队列。 自己的任务做完后,会去“偷”别的线程队列尾部的任务继续做。 这样可以尽量让 CPU 忙起来,减少某些线程闲着、某些线程堆积的情况。 ``` ### 适用场景 ``` 1. 并行计算 2. 递归拆分任务 3. 大数组/大集合分段处理 Java 并行流底层默认就基于 ForkJoinPool。 ``` --- ## 15. 伪共享与性能优化 ### 什么是伪共享 ``` CPU 按缓存行读取数据,常见一行是 64 字节。 如果两个线程分别修改两个无关变量,但这两个变量刚好落在同一缓存行里, 那么它们会互相导致缓存失效,看起来像“共享”了一样,这就是伪共享。 ``` ### 为什么会拖慢性能 ``` 线程 A 改变量 x → 所在缓存行失效 线程 B 改变量 y → 同一缓存行再次失效 虽然 x 和 y 逻辑上无关,但缓存一致性流量会非常大。 ``` ### 常见处理方式 ``` 1. 热点变量分离存放 2. 用填充字段做 cache line padding 3. 在特定场景下使用 @Contended 4. 像 LongAdder 这种分段累加,本质上也是在减少热点争用 ``` --- ## 16. 如何优雅停止线程 ### 不推荐 stop() ``` Thread.stop() 已废弃,因为它会粗暴终止线程,可能让共享数据处于不一致状态。 ``` ### 常见做法 ```java class Worker implements Runnable { private volatile boolean running = true; public void shutdown() { running = false; } @Override public void run() { while (running && !Thread.currentThread().isInterrupted()) { doWork(); } cleanup(); } } ``` ```java Thread t = new Thread(new Worker()); t.start(); t.interrupt(); ``` ### 工程化理解 ``` 优雅停止的重点不是“立刻停”,而是: 1. 线程能感知退出信号 2. 正在阻塞时也能被唤醒 3. 有机会做资源释放和收尾 在线程池场景下通常先 shutdown(),必要时再 shutdownNow()。 ``` --- ## 17. 面试高频 Q&A **Q:synchronized 和 ReentrantLock 的区别?** A:synchronized 是 JVM 内置关键字,自动释放锁;ReentrantLock 是 Java 代码实现(基于 AQS),需手动 unlock(必须在 finally 中)。ReentrantLock 额外支持:可中断获取锁、超时获取锁、公平锁、多个 Condition 精确唤醒。JDK 6+ 两者性能相近,简单场景用 synchronized,需要高级功能用 ReentrantLock。 **Q:volatile 能保证原子性吗?** A:不能。volatile 只保证可见性和有序性。`i++` 是读-改-写三步操作,volatile 无法保证其原子性。需要原子性用 AtomicInteger 或 synchronized。 **Q:AQS 的原理是什么?** A:AQS 用一个 volatile int state 表示同步状态,用 CLH 双向链表存放等待线程。获取锁时 CAS 修改 state,失败则将线程封装为 Node 加入队列并 park 挂起;释放锁时修改 state 并 unpark 唤醒队列中的第一个线程。ReentrantLock、Semaphore、CountDownLatch 等都基于 AQS 实现。 **Q:CountDownLatch 和 CyclicBarrier 的区别?** A:CountDownLatch 是一次性的,一个或多个线程等待其他线程完成(countDown 到0后 await 返回);CyclicBarrier 是可重用的,多个线程互相等待,都到达屏障点后一起继续,可以设置屏障动作。 **Q:线程池的工作流程?为什么不推荐 Executors?** A:提交任务时:线程数 < corePoolSize → 创建核心线程;否则 → 放入队列;队列满且线程数 < maximumPoolSize → 创建非核心线程;否则 → 执行拒绝策略。不推荐 Executors 是因为 newFixedThreadPool 使用无界队列可能 OOM,newCachedThreadPool 最大线程数无限制可能 OOM。推荐直接用 ThreadPoolExecutor 明确指定所有参数。 **Q:ThreadLocal 的内存泄漏是怎么产生的?如何解决?** A:ThreadLocalMap 的 Entry 中,key(ThreadLocal 对象)是弱引用,GC 时会被回收变为 null;但 value 是强引用,key 为 null 后 value 无法被访问也无法被 GC 回收。在线程池场景下线程不销毁,导致内存泄漏。解决:使用完 ThreadLocal 后必须调用 remove() 清理。 > 💬 **Q:key 为什么不设置为强引用呢?** > > 如果 key 是强引用,泄漏更严重,连兜底清理的机会都没有。 > > ``` > 强引用 key: > threadLocal = null ← 你以为它该被回收了 > 但:Thread → ThreadLocalMap → Entry → key(强引用) → ThreadLocal 对象 > → ThreadLocal 对象永远不会被 GC > → key 和 value 都泄漏,而且无法自动清理 > > 弱引用 key(当前设计): > threadLocal = null ← 外部没有强引用了 > Thread → ThreadLocalMap → Entry → key(弱引用) → ThreadLocal 对象 > → GC 时 key 被回收变成 null > → 下次 get/set/remove 时,ThreadLocalMap 发现 key=null → 自动清理该 Entry > → value 也被释放 → 至少有兜底清理的机会 > ``` > > 弱引用是一种"兜底"设计:即使你忘了调 `remove()`,key 被 GC 后 ThreadLocalMap 在后续操作中还有机会自动清理过期 Entry。强引用连这个机会都没有。当然最佳实践还是主动调 `remove()`,不要依赖弱引用的自动清理。 > > --- > > 💬 **Q:大白话解释一下,是因为持有当前线程的引用导致生命周期与线程一致吗?** > > 对,根源就在这里。ThreadLocalMap 是 Thread 对象身上的一个字段,线程不死它就不会被 GC。 > > ``` > 你在方法里用了 ThreadLocal: > public void handleRequest() { > ThreadLocal<BigObject> tl = new ThreadLocal<>(); > tl.set(new BigObject()); // 塞了 10MB 数据 > // 方法结束,tl 这个局部变量没了 > } > > 你以为 10MB 该被回收了?但是: > > 线程池里的线程不会死 > → Thread 对象还在 > → Thread.threadLocalMap 还在(挂在线程身上) > → Map 里有一条 Entry:key=tl, value=10MB > → 10MB 一直被引用着,GC 回收不了! > > 这就是"生命周期跟线程一致"的意思: > 普通变量:方法结束就没了 > ThreadLocal 里的值:线程不死就不会没 > ``` > > 弱引用 key 的作用就是:让 GC 能回收掉没人用的 ThreadLocal 对象 → key 变成 null → Map 下次操作时发现 key=null → 顺手把 value 也清了。不是 100% 可靠(如果后续没操作 Map 就不会触发清理),所以还是要手动 `remove()`。 > > --- > > 💬 **Q:有没有可能出现还没用到就被清理的情况?** > > 不会。弱引用被 GC 回收的前提是:没有任何强引用指向这个 ThreadLocal 对象。只要你还持有它的引用,GC 就不会动它。 > > ``` > static 声明(最常见): > private static final ThreadLocal<User> USER = new ThreadLocal<>(); > → static final 变量,类存在它就存在 → 永远有强引用 → 弱引用永远不会生效 > > 局部变量: > public void handle() { > ThreadLocal<String> tl = new ThreadLocal<>(); > tl.set("hello"); > tl.get(); // 方法还没结束,tl 在栈帧上 → 有强引用 → 不会被 GC > } > // 方法结束后 tl 没了 → 这时候弱引用才可能生效 > > 成员变量: > private ThreadLocal<String> cache = new ThreadLocal<>(); > → 只要对象还在,cache 就有强引用 → 不会被 GC > ``` > > 弱引用只在"你已经丢掉了 ThreadLocal 引用"之后才会生效。你还拿着它的时候,GC 不会碰它。所以正常使用不存在"还没用就被清理"的问题。 **Q:ConcurrentHashMap 的 get 操作需要加锁吗?** A:不需要。Node 的 val 和 next 字段用 volatile 修饰,保证可见性。get 操作只读不写,不需要加锁,性能极高。 **Q:什么是 CAS?有什么问题?** A:CAS(Compare And Swap)是 CPU 级别的原子指令,比较内存中的值是否等于期望值,是则更新为新值,否则重试。主要问题:① ABA 问题(值从A改为B再改回A,CAS 无法感知),用 AtomicStampedReference 加版本号解决;② 自旋开销(竞争激烈时大量 CPU 空转),用 LongAdder 分段累加解决;③ 只能保证单个变量的原子性,多个变量需要用 synchronized 或 AtomicReference。 **Q:LongAdder 为什么比 AtomicLong 快?** A:AtomicLong 高并发时多个线程同时 CAS 同一个变量,大量失败重试浪费 CPU。LongAdder 采用分段累加:维护 base 值和 Cell[] 数组,低竞争时 CAS 更新 base,高竞争时每个线程更新自己对应的 Cell,减少竞争。读取时 sum = base + Σ Cell[i]。代价是 sum() 不是实时精确值,适合写多读少的统计场景。
预览
发布文章
添加摘要让读者更快了解文章内容
取消
确认发布
AI 写作助手
输入一个主题,AI 将为你生成一篇 Markdown 博客文章
AI 正在写作中...
取消
开始生成
AI 优化助手
描述你的修改需求,AI 将在原文基础上进行补充或微调
AI 正在优化中...
取消
开始优化
画布
从已有图里选
✕
图名
保存后生成 /images/excalidraw/<图名>.svg(只能用字母、数字、短横线、下划线、点)
取消
保存并插入