1. 为什么需要关注并发编程的核心特性
第一次接触Java并发编程时，我像大多数开发者一样，简单地认为加个synchronized就能解决所有问题。直到线上系统出现诡异的数值错误和不可复现的bug，才意识到并发问题远比想象中复杂。那段时间，我经常在深夜被报警短信惊醒，排查那些只在百万分之一请求量级才会出现的并发问题。
Java内存模型(JMM)定义了多线程环境下变量的访问规则，而原子性、可见性、有序性正是这个模型的三大支柱。理解它们，就相当于拿到了解决并发问题的万能钥匙。我曾用两周时间重构过一个支付系统的余额扣减模块，在深入理解这些特性后，最终将TPS从200提升到1500，错误率从0.1%降到0.0001%。
2. 原子性：不可分割的操作
2.1 什么破坏了原子性
我见过最典型的原子性问题是在电商促销时，库存管理系统出现的超卖现象。看这段代码：
java复制public class Inventory {
private int stock = 100;
public void deduct() {
if (stock > 0) {
// 模拟业务处理耗时
try { Thread.sleep(10); }
catch (InterruptedException e) {}
stock--;
}
}
}
当100个线程同时执行deduct()时，最终stock很可能变成-5。这是因为stock--看似一行代码，实际包含读取、计算、写入三个步骤，线程切换可能发生在任意两个步骤之间。
2.2 保证原子性的实战方案
在我的项目经验中，根据不同场景有这些解决方案：
- synchronized：适合简单的临界区保护
java复制public synchronized void deduct() { ... }
- ReentrantLock：需要更灵活控制时使用
java复制private final Lock lock = new ReentrantLock();
public void deduct() {
lock.lock();
try {
if (stock > 0) stock--;
} finally {
lock.unlock();
}
}
- AtomicInteger：适合简单计数器
java复制private AtomicInteger stock = new AtomicInteger(100);
public void deduct() {
stock.decrementAndGet();
}
踩坑记录：曾经在金融项目中误用volatile保证原子性，结果依然出现数据错乱。记住volatile不保证复合操作的原子性！
3. 可见性：线程间的内存隔离墙
3.1 可见性问题现场还原
去年排查过一个线上故障：配置中心修改参数后，部分服务器始终读取旧值。最终发现是如下代码导致：
java复制public class Config {
private static boolean updated = false;
public void refresh() {
// 加载新配置...
updated = true;
}
public void apply() {
while(!updated) {
// 等待配置更新
}
// 应用新配置...
}
}
问题在于：线程A执行refresh()后，updated的改动可能停留在CPU缓存，线程B的apply()永远读取不到新值。
3.2 解决可见性的五种武器
经过多个项目实践，我总结出这些方案：
- volatile关键字：轻量级解决方案
java复制private volatile boolean updated;
- synchronized同步块：利用管程规则保证可见性
java复制public synchronized void refresh() { ... }
- final字段：初始化完成后保证可见
java复制private final Map<String, String> config;
- Atomic类：底层使用volatile实现
java复制private AtomicBoolean updated = new AtomicBoolean();
- Lock接口：与synchronized类似
java复制private final Lock lock = new ReentrantLock();
性能小贴士：在超高并发场景下，过度使用volatile会导致缓存频繁失效。我的经验是读多写少用Atomic，写多用Lock。
4. 有序性：代码执行的"错觉"
4.1 指令重排序的陷阱
曾有个订单系统出现匪夷所思的bug：偶尔会有订单完成通知比订单创建通知先到达。最终发现是双重检查锁(DCL)的实现有问题：
java复制public class OrderService {
private static OrderService instance;
public static OrderService getInstance() {
if (instance == null) {
synchronized(OrderService.class) {
if (instance == null) {
instance = new OrderService();
}
}
}
return instance;
}
}
问题在于new OrderService()可能被重排序：先分配内存地址，再初始化对象。导致其他线程拿到未初始化的实例。
4.2 控制有序性的实践方法
- volatile禁止重排序：修复DCL问题
java复制private volatile static OrderService instance;
-
happens-before规则：
- 线程start()前的操作对线程可见
- 线程interrupt()前的操作对检测到中断的代码可见
- 对象构造函数的最后一行操作对finalizer可见
-
内存屏障使用：在Disruptor等高性能框架中常见
java复制// 写屏障
UNSAFE.storeFence();
// 读屏障
UNSAFE.loadFence();
5. 综合应用：设计线程安全的计数器
结合三大特性，这是我常用的线程安全计数器模板：
java复制public class HybridCounter {
private final AtomicInteger count = new AtomicInteger();
private volatile boolean stable;
public void increment() {
int oldVal, newVal;
do {
oldVal = count.get();
newVal = oldVal + 1;
} while (!count.compareAndSet(oldVal, newVal));
stable = (newVal % 100 == 0); // 每100次更新稳定状态
}
public int get() {
return count.get();
}
public boolean isStable() {
return stable;
}
}
这个实现中：
- AtomicInteger保证原子性
- volatile保证stable的可见性
- CAS操作隐含内存屏障保证有序性
6. 常见问题排查指南
根据多年线上问题排查经验，我整理了这份速查表：
| 现象 | 可能原因 | 排查工具 | 解决方案 |
|---|---|---|---|
| 数值偶尔错误 | 原子性破坏 | jstack查看锁竞争 | 使用Atomic或同步块 |
| 线程卡死在循环 | 可见性问题 | jconsole内存视图 | 添加volatile修饰 |
| 对象状态不一致 | 指令重排序 | JMM检查工具 | 使用final/volatile |
| 高并发下性能差 | 锁竞争激烈 | JFR采样 | 改用CAS或分段锁 |
7. 性能优化实战技巧
- 读写分离：CopyOnWriteArrayList适合读多写少场景
- 减小锁粒度：ConcurrentHashMap的分段锁设计
- 无锁编程：LongAdder比AtomicLong在高并发下性能更好
- 线程局部变量：ThreadLocal避免共享变量
- 并发容器选择：
- 低竞争：ConcurrentLinkedQueue
- 高竞争：LinkedBlockingQueue
在最近的消息队列项目中，通过将synchronized替换为ReentrantLock+Condition，配合volatile状态标志，使吞吐量提升了3倍。
8. 从JVM角度看三大特性
理解底层原理能更好运用这些特性：
-
原子性实现：
- synchronized：monitorenter/monitorexit字节码
- CAS：CPU的cmpxchg指令
-
可见性实现：
- volatile：插入LoadStore屏障
- final：构造函数结束后冻结字段
-
有序性实现：
- 内存屏障：LoadLoad/LoadStore等
- as-if-serial：单线程执行结果不变
通过-XX:+PrintAssembly查看汇编代码，可以直观看到这些机制如何工作。
9. 新一代并发工具的应用
在Java8+项目中，我更多使用这些现代工具：
- CompletableFuture：处理异步任务链
java复制CompletableFuture.supplyAsync(() -> getData())
.thenApply(this::process)
.thenAccept(this::save);
- StampedLock：乐观读锁提升性能
java复制StampedLock lock = new StampedLock();
long stamp = lock.tryOptimisticRead();
// 读操作...
if (!lock.validate(stamp)) {
stamp = lock.readLock();
// 重新读...
}
- LongAdder：替代AtomicLong的高性能计数器
这些工具内部都精心处理了三大特性问题，让我们能更专注于业务逻辑。