一个统计任务用四个线程各自累加十万次,预期结果四十万。上线后日志里出现的数字是 146797,下一次跑又变成 183204,每次都不同,而且总是偏小。代码里就是一行 count++,没有异常,没有报错,数字就是不对。
这不是 JDK 的 bug,是竞态条件。count++ 看起来是一步,编译后其实是三步:读当前值、加一、写回去。两个线程可能同时读到同一个旧值,各自加一写回,后写的覆盖先写的,一次自增就丢了。线程越多、竞争越激烈,丢得越多。
这篇讲多线程的四件核心事:线程怎么启动和管理、线程池怎么配、共享状态怎么保护、死锁和可见性怎么排查。多线程问题的共同点是「不确定」——同样的代码,有时对有时错,本地复现不了,压测才出现。理解底层机制,比记住几个 API 更重要。
先复现:四个线程,四十万变成十四万
把刚才的场景写成可运行的代码。四个线程,每个循环十万次,分别用普通 int、AtomicInteger、LongAdder 和 synchronized 累加:
static int plain = 0;
static int syncCount = 0;
static AtomicInteger atomic = new AtomicInteger();
static LongAdder adder = new LongAdder();
for (int i = 0; i < 4; i++) {
new Thread(() -> {
for (int j = 0; j < 100000; j++) plain++;
}).start();
}
javac -encoding UTF-8 JavaThreadsDemo.java
java -Dstdout.encoding=UTF-8 -cp . JavaThreadsDemo
普通 int 累加 : 146797
AtomicInteger : 400000
LongAdder : 400000
synchronized 累加 : 400000
普通 int 的结果每次都不一样,本机这一次是 146797,下一次可能是 18 万,但都小于 400000。其余三种都精确等于 400000。这个对比说明了一个关键点:不是「加了锁就一定慢」,也不是「用了原子类就一定对」,而是「先要保证正确,再谈性能」。
普通 int 的累加没有同步,三个步骤之间可以被任何线程插入。原子类用 CAS(比较并交换)保证「读、改、写」是一个原子操作;LongAdder 把计数分散到多个单元格,最后求和,竞争激烈时比单一的原子变量更快;synchronized 用监视器锁把整段代码串行化。三种方案各有适用场景,但都解决了「丢更新」。
注意 LongAdder 的 sum() 不是一个原子快照:求和的过程中其他线程还在加,得到的是一个近似值。统计报表可以用,精确对账不能用。需要精确值就用 AtomicLong 或加锁。
线程的启动与生命周期
创建线程有两种常见写法:继承 Thread 并重写 run,或者实现 Runnable 再交给 Thread。后者更灵活,因为 Java 只能单继承,实现接口不占继承名额。JDK 还提供了 Callable 加 Future,能返回结果、抛异常,适合交给线程池执行。
启动必须调 start(),不能直接调 run()。直接调 run() 就是一次普通方法调用,代码在调用者线程里执行,根本没有新线程。这个错误很常见,表现是「明明开了线程,为什么还是串行」。start() 只能调用一次,第二次会抛 IllegalThreadStateException。
线程的状态大致有新建、可运行、阻塞、等待、计时等待、终止。可运行不等于正在占 CPU,它可能在等调度。阻塞是在等锁,等待是在等别的线程通知,计时等待是带超时的等待。用 jstack 看线程栈时,状态和栈顶方法能告诉你它卡在哪:等锁、等 IO、还是真的在算。操作系统如何调度线程、时间片怎么分配,见 操作系统:线程调度。
守护线程(daemon)是一个容易忽略的属性。JVM 在所有非守护线程结束后就会退出,不管守护线程有没有跑完。把线程设为守护线程,能避免「主线程结束了,程序还不退出」,但也意味着它可能在任意时刻被终止,finally 不保证执行。需要保证完成的清理任务,不要放在守护线程里。
未捕获异常默认只打印到 stderr,不会让整个进程崩溃,也不会自动通知别处。需要统一处理时,给线程设置 UncaughtExceptionHandler,或者在线程池里重写 afterExecute,把异常记进日志和监控。否则一个后台线程静默死掉,主流程完全不知道。
给线程起名字是个小习惯,收益很大。默认名字是 Thread-0、pool-1-thread-1 这类,日志里看不出是谁。把线程名写成「模块名加编号」,jstack 和日志一眼就能对上。线程优先级不要依赖,Java 的优先级只是给操作系统的建议,不同平台行为不同,靠它调整执行顺序不可靠。
线程池:核心线程、队列和拒绝策略
直接 new Thread 的问题是创建和销毁成本高,线程数量也不受控。线程池把线程复用起来,任务提交到队列,由固定数量的线程取出来执行。Java 的 ThreadPoolExecutor 有七个关键参数:核心线程数、最大线程数、空闲存活时间、任务队列、线程工厂、拒绝策略,以及是否允许核心线程超时。
执行顺序是:核心线程没满就新建线程;核心线程满了就进队列;队列满了才扩到最大线程数;再满就执行拒绝策略。很多人以为「任务多了就加线程」,实际是「先排队,排不下才加线程」。这个顺序决定了队列的选择比最大线程数更影响行为。
ThreadPoolExecutor pool = (ThreadPoolExecutor) Executors.newFixedThreadPool(2);
for (int i = 0; i < 8; i++) pool.submit(() -> sleep(500));
Thread.sleep(50);
System.out.println(pool.getCorePoolSize());
System.out.println(pool.getQueue().size());
核心线程数 : 2
排队任务数 : 6
八个任务、两个核心线程,提交后 50 毫秒时两个在执行,六个在队列里等。newFixedThreadPool 的队列是无界的 LinkedBlockingQueue,任务再多也只会排队,不会扩容线程,也不会拒绝。队列无限增长的风险是内存:任务对象越堆越多,最后 OutOfMemoryError。它适合任务量可控、执行时间稳定的场景。
newCachedThreadPool 相反:核心线程数是 0,最大线程数是 Integer.MAX_VALUE,队列是 SynchronousQueue(不存储任务,直接交给线程)。任务一多就不断新建线程,理论上可以创建到系统撑不住。它适合大量短任务,但流量突增时很危险。
生产环境更推荐直接 new ThreadPoolExecutor,显式指定有界队列和拒绝策略。拒绝策略有四种:直接抛异常、在调用者线程里执行、丢弃最旧的任务、直接丢弃。默认的抛异常至少能让问题暴露,静默丢弃最难排查。队列容量、核心线程数、最大线程数要一起算,不能只调一个。
关闭线程池用 shutdown:不再接受新任务,已提交的任务继续执行。shutdownNow 会尝试中断正在执行的任务,并返回没执行的任务列表。中断是协作式的,任务不响应中断就停不下来。关闭之后用 awaitTermination 等一段时间,确认真的结束,否则可能留下未清理的资源。
参数怎么定,可以从任务类型入手。计算密集型的任务,线程数接近 CPU 核数就能跑满,多了只会增加切换;IO 密集型的任务,大部分时间在等网络或磁盘,线程数可以高于核数,但要以压测结果为准。队列容量要给一个上限,至少让系统在过载时拒绝而不是慢慢耗尽内存。
死锁:两边各持一把锁,互相等对方
死锁的经典形态是两个线程、两把锁,加锁顺序相反。线程一先拿 A 再等 B,线程二先拿 B 再等 A,两边都不释放,永远等下去。下面这段代码故意构造了这个场景:
Thread t1 = new Thread(() -> {
synchronized (A) { sleep(100); synchronized (B) { } }
}, "t1");
Thread t2 = new Thread(() -> {
synchronized (B) { sleep(100); synchronized (A) { } }
}, "t2");
t1.start(); t2.start(); sleep(300);
long[] ids = ManagementFactory.getThreadMXBean().findDeadlockedThreads();
死锁线程数 : 2
死锁线程 : t1
死锁线程 : t2
ThreadMXBean.findDeadlockedThreads 能主动检测死锁,返回参与死锁的线程 id;没有死锁时返回 null。本机实测两个线程都被识别出来了。这个能力适合做健康检查或故障自诊断,但不能替代预防:检测到的时候,业务已经卡住了。
线上更常用的是 jstack。它会把所有线程的栈打出来,并在末尾专门写一段「Found one Java-level deadlock」,列出每个线程持有什么锁、在等什么锁。看到这段,基本不用再猜。没有死锁时,也可以用它看线程都卡在哪里,是等数据库连接、等网络响应,还是在空转。
死锁有四个必要条件:互斥、持有并等待、不可抢占、循环等待。破坏其中任意一个就能避免。工程上最有效的是破坏循环等待:给所有锁定义全局顺序,任何线程都按同样的顺序加锁。其次是缩小锁的范围,尽量不要在持锁期间调用外部方法,更不要在持锁时等待 IO。
还有一个变种叫活锁:两个线程都愿意让路,结果反复避让,谁也没进展。表现是 CPU 不低、日志一直在重试、任务永远完不成。它不像死锁那样能被自动检测,只能靠限流、随机退避和超时来打破。
可见性:为什么循环停了不下来
比死锁更隐蔽的是可见性问题。一个线程改了标志位,另一个线程可能永远看不到,因为编译器把读操作优化成了「只读一次」,或者 CPU 缓存没有同步。下面这段代码用一个普通布尔值控制循环:
static class FlagHolder { boolean running; }
FlagHolder holder = new FlagHolder();
holder.running = true;
Thread vt = new Thread(() -> { while (holder.running) { } });
vt.start(); sleep(200);
holder.running = false;
vt.join(1000);
System.out.println(!vt.isAlive());
非 volatile 线程停止 : false
volatile 线程停止 : true
普通布尔值的版本,主线程把 running 改成 false,循环线程一秒内没有停止,join 超时返回,打印 false。加上 volatile 的版本,一秒内正常停止,打印 true。这是本机 JDK 21 上真实跑出来的结果,不是理论推演。
volatile 保证两件事:每次读都从主内存拿最新值,每次写都立刻刷回主内存;编译器和 CPU 不会把 volatile 访问重排到其他内存操作之外。它不保证原子性,所以 volatile int count; count++ 仍然是错的,还是一样会丢更新。需要原子性就用原子类或锁。
synchronized 除了互斥,也提供可见性:释放锁之前的写,对之后获得同一把锁的线程可见。线程的 start 和 join 也建立类似的保证:start 之前的写对新线程可见,线程结束前的写对 join 之后的线程可见。这些规则统称 happens-before,是判断「要不要加 volatile」的依据。
常见的双重检查单例就是可见性的经典案例。如果实例字段不加 volatile,另一个线程可能看到一个「已经赋值但构造还没完成」的对象。加了 volatile 之后,初始化和引用赋值之间的重排被禁止,才能安全发布。这类问题发生概率很低,但一旦发生,错误出现在离赋值很远的地方。
另一个常见误区是「用了线程安全的集合就万事大吉」。ConcurrentHashMap 的单个操作是安全的,但「先检查再写入」这种组合操作不是原子的。两个线程同时判断「键不存在」,然后都执行 put,结果仍然可能不符合预期。组合操作要自己加锁,或者用 computeIfAbsent 这类原子方法。
这三层解释了为什么「本地跑没问题」:数据量小、执行时间短、JIT 还没优化、CPU 缓存刚好同步了。换一台机器、换一个负载,结果就可能不同。并发问题不能靠「我试过了」来证明正确。
出问题时先看哪里
| 现象 | 真实原因 | 第一步查什么 |
|---|---|---|
| 计数器结果偏小,每次还不一样 | i++ 不是原子操作,多线程丢更新 | 看共享变量有没有同步;改用原子类、LongAdder 或锁 |
| 程序卡住,CPU 却不高 | 线程互相等锁,形成死锁 | jstack 看有没有 deadlock 段落;用 findDeadlockedThreads 检测 |
| 一个 CPU 核心跑满,任务不结束 | 无锁循环在空转,或者活锁反复重试 | 看线程栈是不是停在某个 while 循环;加超时和退避 |
| 线程数持续上涨 | 用了缓存线程池,或任务里又创建线程 | 看池类型和最大线程数;打印活跃线程数和队列长度 |
| 内存持续上涨,最后 OOM | 无界队列堆积任务,或任务持有大对象不释放 | 看队列长度和任务对象;换成有界队列和拒绝策略 |
调了 shutdown 但任务还在跑 | 任务不响应中断,或者根本没等 awaitTermination | 检查任务里的阻塞调用;关闭后等待并记录未结束的任务 |
加了 volatile 计数还是错 | volatile 只保证可见性,不保证原子性 | 看是不是复合操作;改用原子类或锁 |
捕获 InterruptedException 后线程停不下来 | 吞掉了异常,没有恢复中断标记 | 看 catch 块有没有 Thread.currentThread().interrupt() |
| 主线程结束,程序不退出 | 还有非守护线程在运行 | 用 jstack 看残留线程;确认是否需要设为 daemon |
排查并发问题,先分清是「结果不对」「卡住」还是「资源涨」。结果不对多半是竞态或可见性;卡住多半是死锁、活锁或无限等待;资源涨多半是线程或队列没有上限。三类问题的工具不同,但第一步都一样:把线程栈和线程状态拿到手。
边界与代价
多线程能提高吞吐,但不是免费的,也不是所有场景都适合:
- 线程有内存成本:每个平台线程都要分配栈空间,线程越多,内存占用越大。线程数不是越多越好,超过 CPU 能并行处理的数量,切换成本会吃掉收益。
- 锁会带来串行化:锁的范围越大,并发度越低。把整个方法标成
synchronized最省事,也最容易把系统变成单线程。 - 并发问题难以复现:依赖时序、调度、CPU 缓存和 JIT 优化,本地测试通过不代表线上正确。需要压力测试、代码审查和对内存模型的理解。
- 线程池参数没有标准答案:CPU 密集和 IO 密集的最优值不同,任务耗时分布、依赖服务、内存限制都会影响。只能压测加监控,逐步调整。
- 中断是协作式的:调
interrupt只是设置标记,线程不检查就停不下来。阻塞方法通常响应中断,但自定义循环必须自己检查isInterrupted。 - 守护线程不保证清理:JVM 退出时守护线程直接被终止,
finally不保证执行。写文件、提交事务、释放资源这类收尾工作不要放在守护线程里。
还有一个现实约束:平台线程的数量受操作系统限制。每个请求开一个线程,连接数一上万就撑不住。JDK 21 的虚拟线程就是为这个场景准备的,下一篇会实测它和平台线程的差别。
当天能自己验证的练习
- 四个线程各累加十万次,分别用普通
int、AtomicInteger、LongAdder和synchronized,多跑几次,记录普通int每次的结果差异。 - 把
new Thread(runnable).start()改成new Thread(runnable).run(),观察输出顺序和线程名的变化,理解为什么没有新线程。 - 用
newFixedThreadPool(2)提交八个耗时任务,打印核心线程数和队列长度;再把池换成newCachedThreadPool重复一次,对比行为。 - 构造两个线程、两把锁、相反加锁顺序,用
ThreadMXBean.findDeadlockedThreads检测,再用jstack查看死锁段落。 - 用普通布尔值和
volatile布尔值各写一个循环退出测试,记录join是否超时;再把volatile int的自增跑一遍,确认它仍然会丢更新。
小结
三句话收一下:i++ 不是原子操作,多线程共享计数要用原子类、LongAdder 或锁;线程池的执行顺序是先核心线程、再队列、再扩容、最后拒绝,无界队列会把内存拖垮;volatile 只保证可见性不保证原子性,死锁靠固定加锁顺序预防,靠 jstack 和 ThreadMXBean 发现。
下一篇讲异步与虚拟线程。CompletableFuture 把「等待」从线程里拿出来,虚拟线程把「一个请求一个线程」的成本降下来;今天遇到的线程数量上限和阻塞浪费,正是它们要解决的问题。