同一段代码,单线程运行正常,上线后却偶尔少扣一次库存、串了用户信息,或者一直停不下来。问题通常不在“有没有创建线程”,而在于:多个执行路径是否同时访问了同一份可变状态,以及它们如何协调访问。
这篇先把线程安全的基础讲清楚:如何识别共享状态,为什么一次递增会丢失,synchronized、volatile 和 ThreadLocal 各自解决什么问题。示例以 Java 21 为准,业务背景使用下单和库存,但内存示例只对一个 JVM 内的对象负责。
1. 先判断任务是否适合并发
并发是多个任务在一段时间内交错推进;并行是多个任务在同一时刻执行。一个 CPU 核心也能通过调度让多个线程并发运行,但不代表计算吞吐会随线程数增加。
例如,商品详情页要查询商品、运费和推荐列表。如果三个查询互相独立,并发发起可以减少串行等待。相反,必须先创建订单才能取得订单号的步骤,不能仅靠“开三个线程”消除依赖。
引入线程之前,先回答三个问题:
- 任务独立吗? 后一步是否依赖前一步的结果?
- 瓶颈在哪里? 是 CPU 运算、远程等待,还是数据库连接不足?
- 结果如何收尾? 谁等待完成、处理异常、超时后停止工作?
线程会带来调度、上下文切换和协调成本。把一个很短的计算拆到线程池,可能比直接执行更慢;让请求并发访问一个已经饱和的数据库,则可能让所有请求都更慢。
2. start、run 和结果等待是三件事
下面的 run() 只是当前线程中的普通方法调用;只有 start() 才会启动新线程来执行任务。
Runnable task = () -> System.out.println(Thread.currentThread().getName());
Thread worker = new Thread(task, "order-worker");worker.run(); // 由调用者线程执行worker.start(); // 由 order-worker 执行worker.join(); // 调用者等待 worker 结束一个 Thread 对象只能启动一次。业务代码也不宜为每个请求无约束地创建平台线程;实际任务提交和资源管理通常交给执行器,见线程池与异步编程。
需要返回值时,可以把任务表示为 Callable<T>,通过 Future<T> 等待结果:
Callable<Integer> task = () -> 42;FutureTask<Integer> future = new FutureTask<>(task);Thread worker = new Thread(future, "price-worker");worker.start();
try { int price = future.get(1, TimeUnit.SECONDS); System.out.println(price);} finally { future.cancel(true);}这是需要导入 java.util.concurrent.*、并由调用方法处理异常的片段。get 可能报告任务异常、等待超时或调用线程被中断;cancel(true) 只是尝试中断正在运行的任务,任务还需要配合退出。等待超时并不自动撤销已经产生的业务效果。
3. 一次 count++ 为什么会丢失
先把递增展开:
int before = count;int after = before + 1;count = after;假设 count 初始为 0,两个线程可能这样交错:
| 时刻 | 两个线程的操作 |
|---|---|
| 1 | A 读取 0 |
| 2 | B 也读取 0 |
| 3 | A 写入 1 |
| 4 | B 写入 1 |
两个线程各加了一次,最终值却是 1。这里每一次读写即使都能被对方看见,也无法阻止它们基于同一个旧值计算。
给 count 加 volatile 仍会出现这个结果。要保护的是“读取—计算—写回”整个操作。
final class Counter { private int count;
public synchronized void increment() { count++; }
public synchronized int value() { return count; }}当多个线程访问同一个 Counter 实例时,它们通过同一个监视器协调。读取方法也遵循同样的同步规则,外部不能绕过方法直接修改字段。若只是计数,也可以使用 AtomicInteger.incrementAndGet(),原理和适用边界见 CAS 专题。
库存操作比递增多了一步检查。下面两次单独加锁并不够:
先调用 getStock() 判断有库存中间另一个线程可能扣完库存再调用 decreaseStock() 扣减“检查并扣减”必须属于同一个受保护的操作。方法分别线程安全,不代表把它们拼起来的业务流程也线程安全。
4. 用三个问题理解线程安全
原子性:中间状态能否被插入
原子性关注一个操作能否作为整体完成。上面的 count++ 和“检查库存再扣减”都是复合操作。
原子性的范围必须明确:Java 锁可以保护内存中的临界区;数据库事务可以协调数据库修改。给某个 Java 方法加锁,不会自动把远程支付和数据库提交变成一个原子操作。
可见性:读取者何时能依赖写入结果
Java 内存模型通过 happens-before 关系规定跨线程的可见性保证。例如,同一监视器的解锁与后续加锁,以及一个线程结束与另一个线程成功从 join() 返回,都能建立相应关系。
判断代码时应寻找这样的同步关系,而不是把线程想象成“每隔一会儿刷新一下缓存”。没有同步的代码即使反复运行看起来正常,也不能据此推导其正确性。JLS 第 17 章
有序性:其他线程能依赖哪些先后关系
编译器和处理器可以在语义允许的范围内优化执行顺序。同步机制为跨线程观察建立约束;volatile 并不意味着程序中的所有指令都禁止重排。
工程上更有效的做法是:先确定需要发布哪些数据,再选择能建立同步关系的方式。不要靠几次日志输出推断内存模型。
5. volatile 适合发布状态,不负责组合业务操作
下面通过一个 volatile 引用发布不可变配置快照:
record Limits(int maxItems, int timeoutMillis) {}
final class CheckoutConfig { private volatile Limits current = new Limits(10, 500);
Limits snapshot() { return current; }
void replace(Limits next) { current = java.util.Objects.requireNonNull(next); }}请求读取一次 snapshot(),后续使用这个快照,便不会把新版本的 maxItems 与旧版本的 timeoutMillis 混在一起。这里 record 只有基本类型字段;如果 record 装着可变列表,还需要处理列表本身的不可变性。
这种“整份替换”的语义适合配置发布。如果两个线程都要“读取旧配置,再据此增加一个值”,仍然可能覆盖对方更新;此时需要锁或 CAS。若把共享 ArrayList 引用声明成 volatile,列表内部的并发增删也不会因此变得安全。
6. 共享状态往往藏在业务对象里
Spring 单例服务通常会被多个请求线程调用。以下字段会把请求数据变成共享状态:
// 错误示例:两个请求会覆盖同一个字段class OrderService { private Long currentUserId;
void createOrder(Long userId) { currentUserId = userId; // 后面的逻辑可能读到另一个请求的用户 }}优先把用户信息作为参数传递,在调用链中保留请求自己的上下文。对于必须共享的数据,明确唯一的访问入口和同步规则。
“局部变量一定线程安全”也需要加上条件:局部变量槽属于当前调用,但变量引用的对象可能仍被其他线程共享。把一个共享 Map 赋给局部变量,没有复制这张 Map。
判断一段代码时,可以沿着引用追问:这份对象还有谁能拿到?谁能修改?读写是否使用同一套规则?
7. ThreadLocal 按线程隔离,不按请求隔离
ThreadLocal 可以让不同线程保存各自的值。在线程池中,工作线程会连续处理不同请求,所以请求结束后值不会自动随请求消失。
在拥有最外层上下文生命周期的入口,可以这样管理:
private static final ThreadLocal<String> CURRENT_USER = new ThreadLocal<>();
void handle(String userId) { CURRENT_USER.set(userId); try { processRequest(); } finally { CURRENT_USER.remove(); }}processRequest() 代表实际业务调用。这种写法适用于入口负责设置和清理的场景;若允许嵌套覆盖上下文,应保存旧值并在退出时恢复,不能把外层值直接清掉。
把任务提交到另一个线程池后,普通 ThreadLocal 的值不会自动跟过去。需要传递的用户 ID、追踪 ID,优先封装成不可变上下文并显式传入。也不要把可变对象同时放入多个线程的 ThreadLocal 后,就认为对象本身已经隔离。ThreadLocal API
8. 线程怎么等,怎么停
Java 线程状态描述的是 JVM 中的状态,不是业务健康程度:
| 状态 | 典型场景 |
|---|---|
| NEW | 创建后尚未启动 |
| RUNNABLE | 正在执行或等待运行资源 |
| BLOCKED | 等待进入 synchronized |
| WAITING | 无期限 join、wait 或 park |
| TIMED_WAITING | sleep 或有期限等待 |
| TERMINATED | 执行已经结束 |
等待 ReentrantLock 的线程常表现为停放等待,不能只搜索 BLOCKED 判断全部锁竞争。RUNNABLE 也不直接等于“正在占用 CPU”。Thread.State API
sleep 暂停当前线程,但不会释放已经持有的监视器。wait 必须在持有对应监视器时调用,并释放这个监视器;它不是释放当前线程持有的所有锁。条件等待应放在循环里,醒来后重新检查条件。
停止线程应使用协作式中断。以消费阻塞队列为例:
void consume(BlockingQueue<Runnable> queue) { try { while (!Thread.currentThread().isInterrupted()) { Runnable task = queue.take(); task.run(); } } catch (InterruptedException e) { Thread.currentThread().interrupt(); }}这里捕获中断后恢复标志并退出循环。若 task.run() 长时间计算且从不检查中断,工作线程仍无法及时退出;若任务执行外部 I/O,还要配置相应客户端超时。任务中的其他异常是否继续消费,应由业务策略明确决定。
9. 用可复现实验验证理解
下载 Java 并发实验工程,解压后在工程目录执行:
mvn test环境为 JDK 21、Maven 3.9。工程包含 12 项测试,不依赖数据库和消息队列。其中三个实验对应本文:
- 用屏障让两个线程都先读到 0,再分别写回 1,稳定复现
volatile不能保证递增原子性。 - 使用同一对象的
synchronized方法,共执行 2000 次递增,验证结果为 2000。 - 在单线程池内连续提交任务,观察
ThreadLocal残留,再验证remove()后不再残留。
实验通过控制交错顺序暴露具体问题;一次压测没复现,并不能证明没有数据竞争。继续阅读时,可根据问题直接选择线程池与异步编程、业务并发实战或锁专题。
If this article helped you, please share it with others!
Some information may be outdated






