一杯咖啡的时间，带你彻底理解Java并发编程的核心概念
引言
作为Java程序员，你一定听说过"可见性"、"原子性"、"有序性"这些概念。但这些抽象的概念往往让人难以理解。今天，让我们通过一个简单的办公室场景，来重新认识这些概念。
一、Java内存模型：一个现代化办公室
想象一下，我们的办公室就是一个小型的公司：
- 公告板（主内存）：放在大厅中央
- 员工的记事本（工作内存）：每个人自己随身携带
- 各位员工（线程）：来来往往处理各种事务
1.1 工作内存 vs 线程栈：不同的抽象层面
在讨论并发问题之前，我们先来理清两个容易混淆的概念：
public class Employee {
private static int companyMoney = 100000; // 公司账户余额-主内存
public void processPayment() {
int salary = 5000; // 局部变量-线程栈
companyMoney -= salary; // 共享变量-涉及工作内存
}
}
线程栈
- 就像员工的个人办公桌
- 存放：个人的文件和工具（局部变量）
- 特点：只有自己能用，不需要和别人共享
工作内存
- 就像员工的记事本
- 存放：公共信息的备份（共享变量的副本）
- 特点：需要和公告板保持同步
1.2 Java内存模型的交互规则
就像公司的规章制度一样，Java内存模型定义了几个重要的规则：
- 主内存与工作内存的交互
class CompanyProcess {
// 主内存变量
volatile int documentVersion = 1;
// 交互过程
void updateDocument() {
// 1. 从主内存读取到工作内存
// 2. 在工作内存中修改
// 3. 写回主内存
documentVersion++;
}
}
- 变量的原子操作
- read：从公告板读取信息
- load：抄写到记事本
- use：查看记事本信息
- assign：在记事本修改
- store：准备更新到公告板
- write：实际更新公告板
二、并发编程的三大困扰
2.1 可见性：错过的会议通知
问题场景
public class MeetingNotice {
private boolean meetingScheduled = false;
// 行政小张：发布会议通知
public void scheduleMeeting() {
prepareMeeting();
meetingScheduled = true;
}
// 小李：一直在等通知
public void waitForMeeting() {
while (!meetingScheduled) {
// 不断查看记事本
}
attendMeeting();
}
}
解决方案
public class MeetingNotice {
// 重要通知必须直接看公告板
private volatile boolean meetingScheduled = false;
// 其他代码不变
}
2.2 原子性：混乱的会议室预订
问题场景
public class MeetingRoom {
private boolean isBooked = false;
public void book() {
// 以下三步不是原子操作
if (!isBooked) { // 1. 检查状态
validateEmployee(); // 2. 验证员工身份
isBooked = true; // 3. 更新状态
}
}
}
解决方案
public class MeetingRoom {
private boolean isBooked = false;
// 加锁保证原子性
public synchronized void book() {
if (!isBooked) {
validateEmployee();
isBooked = true;
}
}
}
2.3 有序性：混乱的入职流程
问题场景
public class Onboarding {
private boolean workstationReady;
private boolean accountCreated;
public void prepare() {
workstationReady = true; // 可能和下面的顺序互换
accountCreated = true;
}
public void checkStatus() {
if (accountCreated && !workstationReady) {
// 账号创建了但工位没准备好？
}
}
}
解决方案
public class Onboarding {
private volatile boolean workstationReady;
private volatile boolean accountCreated;
public synchronized void prepare() {
workstationReady = true;
accountCreated = true;
}
}
三、深入理解happens-before
就像公司的工作流程一样，happens-before规则确定了操作的先后顺序：
- 程序顺序规则：
// 代码中的先后顺序
void process() {
step1(); // 一定在step2之前
step2();
}
- volatile变量规则：
volatile boolean flag;
int data;
// 线程A
data = 42;
flag = true;
// 线程B
if (flag) {
// 一定能看到data = 42
}
- 传递性规则：
// A happens-before B
// B happens-before C
// 则A happens-before C
四、实践建议
- 优先使用高层同步工具
// 不要这样
private volatile boolean flag;
private volatile int count;
// 建议这样
private AtomicBoolean flag = new AtomicBoolean();
private AtomicInteger count = new AtomicInteger();
- 正确使用synchronized
// 同步代码块要够小，但也要确保完整性
synchronized void transfer(Account from, Account to) {
// 放在一个同步块中
from.debit(amount);
to.credit(amount);
}
- volatile的适用场景
public class Config {
private volatile String config;
// 适用于单个变量的读写
// 不适用于复合操作
}
总结
通过办公室的日常场景，我们可以更直观地理解Java并发编程中的核心概念：
- 可见性：就像必须及时查看公告板
- 原子性：就像会议室预订必须一气呵成
- 有序性：就像入职流程必须按步骤来
记住，编写并发程序时：
- 优先使用成熟的并发工具类
- 理解清楚共享变量的访问规则
- 正确使用synchronized和volatile关键字
这些原则不仅适用于Java，在其他编程语言中也同样重要。希望这篇文章能帮助你更好地理解并发编程的核心概念！
参考资料
- 《Java并发编程实战》
- 《深入理解Java虚拟机》
- JSR-133: Java Memory Model and Thread Specification
