JMM与内存可见性

一、Java 内存模型（JMM）概述

1.1 什么是 JMM？

定义：Java Memory Model（JMM）是 Java 虚拟机规范定义的一种内存模型，用于屏蔽各种硬件和操作系统的内存访问差异，实现跨平台的内存访问一致性。

核心目标：

定义程序中变量的访问规则
保证多线程环境下的内存可见性
规定指令重排序的边界

⚠️ 注意区分：

JVM 内存结构：堆、栈、方法区等物理内存布局

JMM：线程间通信的抽象模型（规范）

1.2 JMM 抽象模型

┌─────────────────────────────────────────────────┐

│              主内存（Main Memory）                │

│  所有线程共享的变量存储区域                        │

│  [对象实例] [静态变量] [常量]                      │

└────────┬──────────────────────────┬──────────────┘

         │                          │

    读取 │ 写入                 读取 │ 写入

         ↓                          ↓

┌────────────────────┐    ┌────────────────────┐

│  线程 A 工作内存      │    │  线程 B 工作内存      │

│  [变量副本]          │    │  [变量副本]          │

│  [CPU 缓存]          │    │  [CPU 缓存]          │

└────────────────────┘    └────────────────────┘

关键概念：

术语	说明	对应硬件
主内存	所有线程共享的内存区域	RAM（主存）
工作内存	每个线程私有的内存区域	CPU 缓存（L1/L2/L3）+ 寄存器
变量副本	线程从主内存读取变量到工作内存	缓存行（Cache Line）

1.3 JMM 定义的 8 种操作

JMM 规定了主内存与工作内存之间的交互协议：

操作	作用位置	说明
lock	主内存	锁定变量（独占访问）
unlock	主内存	解锁变量
read	主内存	读取变量到工作内存
load	工作内存	将 read 的值放入工作内存副本
use	工作内存	将工作内存变量传递给执行引擎
assign	工作内存	将执行引擎的值赋给工作内存变量
store	工作内存	将工作内存变量传输到主内存
write	主内存	将 store 的值写入主内存

示例流程：

// 线程 A 执行：x = 1;
1. assign: 工作内存 x_副本 = 1
2. store:  将 x_副本 传输到主内存
3. write:  主内存 x = 1

// 线程 B 执行：int y = x;
1. read:   从主内存读取 x
2. load:   加载到工作内存 x_副本
3. use:    将 x_副本 赋值给 y

二、内存可见性问题

2.1 经典案例：循环不停止

public class VisibilityProblem {
    private static boolean flag = false;  // ⚠️ 问题变量
    
    public static void main(String[] args) throws InterruptedException {
        // 线程 A：读取 flag
        Thread threadA = new Thread(() -> {
            while (!flag) {
                // 死循环
            }
            System.out.println("线程 A 结束");
        });
        
        // 线程 B：修改 flag
        Thread threadB = new Thread(() -> {
            flag = true;
            System.out.println("线程 B 已将 flag 设置为 true");
        });
        
        threadA.start();
        Thread.sleep(100);
        threadB.start();
    }
}

// 运行结果：
// 线程 B 已将 flag 设置为 true
// （线程 A 永远不会结束，死循环）

问题分析：

时间线：
t1: 线程 A 从主内存读取 flag = false 到工作内存
t2: 线程 A 进入循环，一直使用工作内存的 flag（false）
t3: 线程 B 修改主内存 flag = true
t4: 线程 A 的工作内存未感知到变化，继续使用旧值 false

根本原因：CPU 缓存导致的可见性问题

硬件层面解释：

CPU 架构：
┌─────────┐     ┌─────────┐
│ Core 0  │     │ Core 1  │
│ L1 Cache│     │ L1 Cache│
│ flag=0  │     │ flag=1  │  ← 各自缓存不一致
└────┬────┘     └────┬────┘
     └───────┬───────┘
         L3 Cache
             │
         主内存 RAM

2.2 解决方案对比

方案	代码示例	性能	适用场景
1. volatile	`volatile boolean flag`	高	状态标志、单次赋值
2. synchronized	`synchronized(lock) { flag = true; }`	低	需要原子性保证
3. AtomicBoolean	`AtomicBoolean flag = new AtomicBoolean()`	中	CAS 操作
4. final	`final boolean flag = true`	极高	不可变对象

最佳实践（使用 volatile）：

public class VisibilityFixed {
    private static volatile boolean flag = false;  // ✅ 添加 volatile
    
    public static void main(String[] args) throws InterruptedException {
        Thread threadA = new Thread(() -> {
            while (!flag) {
                // 可以正常退出
            }
            System.out.println("线程 A 结束");
        });
        
        Thread threadB = new Thread(() -> {
            flag = true;
            System.out.println("线程 B 已将 flag 设置为 true");
        });
        
        threadA.start();
        Thread.sleep(100);
        threadB.start();
    }
}

// 运行结果：
// 线程 B 已将 flag 设置为 true
// 线程 A 结束  ✅

2.3 可见性问题的三种表现

表现 1：读取不到最新值（上述案例）

表现 2：读取到部分更新的值

public class PartialVisibility {
    private static long value = 0L;  // 64 位（非原子操作）
    
    public static void main(String[] args) {
        // 线程 A：写入 Long.MAX_VALUE
        new Thread(() -> {
            value = Long.MAX_VALUE;  // 0x7FFFFFFFFFFFFFFF
        }).start();
        
        // 线程 B：读取 value
        new Thread(() -> {
            long v = value;
            System.out.println(v);  
            // 可能输出：4294967295（只读到低 32 位）⚠️
        }).start();
    }
}

// 原因：
// 在 32 位系统上，long 的读写分为两步：
// 1. 写入低 32 位
// 2. 写入高 32 位
// 线程 B 可能在步骤 1 和 2 之间读取

表现 3：指令重排序导致的问题（见第三节）

三、重排序

3.1 什么是重排序？

定义：编译器和处理器为了优化程序性能，对指令执行顺序进行调整。

三种重排序：

源代码
  ↓
编译器优化重排序（javac / JIT）
  ↓
指令级并行重排序（CPU）
  ↓
内存系统重排序（缓存、写缓冲）
  ↓
最终执行顺序

3.2 重排序示例

示例 1：编译器重排序

// 原始代码
int a = 1;
int b = 2;
int c = a + b;

// 可能重排为（c 不依赖 b）：
int a = 1;
int c = a + ...; // 先计算部分
int b = 2;
int c = a + b;

示例 2：CPU 指令重排序

// 原始代码
a = 1;  // 写操作 1
b = 2;  // 写操作 2

// CPU 可能重排为（写缓冲优化）：
b = 2;  // 先写 b（缓冲区有空闲）
a = 1;  // 后写 a

3.3 重排序的经典问题：双重检查锁（DCL）

public class Singleton {
    private static Singleton instance;  // ⚠️ 问题：未加 volatile
    
    public static Singleton getInstance() {
        if (instance == null) {              // 检查 1
            synchronized (Singleton.class) {
                if (instance == null) {      // 检查 2
                    instance = new Singleton();  // ⚠️ 关键代码
                }
            }
        }
        return instance;
    }
}

问题分析：

// instance = new Singleton() 实际分为 3 步：
1. memory = allocate();   // 分配内存
2. ctorInstance(memory);  // 初始化对象
3. instance = memory;     // 设置引用

// ⚠️ 可能重排序为：
1. memory = allocate();
3. instance = memory;     // 先设置引用（此时对象未初始化）
2. ctorInstance(memory);  // 后初始化

// 线程 A 执行到步骤 3
// 线程 B 执行检查 1，发现 instance != null
// 线程 B 返回 instance（未初始化的对象）→ 使用时 NPE

执行时序图：

线程 A                          线程 B
──────────────────────────────────────────
分配内存
instance = memory ────────→    if (instance == null)  ✗
                               return instance; ⚠️ 半初始化对象
初始化对象（太晚了）

正确写法：

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 禁止重排序
                }
            }
        }
        return instance;
    }
}

3.4 as-if-serial 语义

定义：不管怎么重排序，单线程程序的执行结果不能改变。

// 示例：
int a = 1;
int b = 2;
int c = a + b;

// 重排序规则：
// ✅ 允许：a = 1; int b = 2; 交换顺序（无依赖）
// ❌ 禁止：c = a + b; 移到 a = 1 之前（有依赖）

// 保证单线程结果：c = 3

数据依赖性：

写后读（RAW）：a = 1; b = a;  // b 依赖 a
写后写（WAW）：a = 1; a = 2;  // 第二个写覆盖第一个
读后写（WAR）：b = a; a = 1;  // a 的新值不能影响 b 的旧读取

⚠️ 有数据依赖的操作不会重排序（单线程内）

四、happens-before 原则

4.1 定义

happens-before：JMM 定义的操作偏序关系，如果 A happens-before B，则 A 的结果对 B 可见。

核心作用：

程序员：不需要理解底层重排序，只需遵循 happens-before 规则
JVM：在不违反 happens-before 的前提下，可以自由优化

4.2 八大 happens-before 规则

规则 1：程序顺序规则（Program Order Rule）

定义：单线程内，按照代码顺序执行。

int a = 1;  // 操作 A
int b = 2;  // 操作 B
int c = a + b;  // 操作 C

// happens-before 关系：
// A happens-before B
// B happens-before C
// 结论：C 读取的 a 和 b 一定是最新值

⚠️ 注意：允许重排序，但必须保证结果一致（as-if-serial）

int a = 1;
int b = 2;  // 可能与 a 重排序（无依赖）
int c = a + b;  // 但 c 一定在 a, b 之后

规则 2：volatile 变量规则（Volatile Variable Rule）

定义：对 volatile 变量的写操作 happens-before 后续对该变量的读操作。

public class VolatileExample {
    private volatile boolean flag = false;
    private int data = 0;
    
    // 线程 A
    public void writer() {
        data = 42;         // ① 普通写
        flag = true;       // ② volatile 写
    }
    
    // 线程 B
    public void reader() {
        if (flag) {        // ③ volatile 读
            int x = data;  // ④ 普通读
            // x 一定等于 42 ✅
        }
    }
}

// happens-before 链：
// ① happens-before ②（程序顺序规则）
// ② happens-before ③（volatile 规则）
// ③ happens-before ④（程序顺序规则）
// 结论：① happens-before ④（传递性）

内存语义图：

线程 A                          线程 B
──────────────────────────────────────────
data = 42
flag = true (volatile 写)
  │                           
  │  volatile 内存屏障         
  └────────────────────→   if (flag) volatile 读
                              int x = data; ✅ 看到 42

规则 3：锁规则（Monitor Lock Rule）

定义：对锁的解锁 happens-before 后续对该锁的加锁。

public class SynchronizedExample {
    private int data = 0;
    
    // 线程 A
    public synchronized void writer() {
        data = 42;  // ① 写操作
    }  // ② 解锁
    
    // 线程 B
    public synchronized void reader() {  // ③ 加锁
        int x = data;  // ④ 读操作
        // x 一定等于 42 ✅
    }
}

// happens-before 链：
// ① happens-before ②（程序顺序规则）
// ② happens-before ③（锁规则）
// ③ happens-before ④（程序顺序规则）
// 结论：① happens-before ④

图示：

线程 A              Monitor              线程 B
─────────────────────────────────────────────────
data = 42
unlock ────────→ [锁释放] ────────→ lock
                                      int x = data; ✅

规则 4：线程启动规则（Thread Start Rule）

定义：Thread.start() happens-before 该线程的任何操作。

public class ThreadStartExample {
    private int data = 0;
    
    public static void main(String[] args) {
        ThreadStartExample obj = new ThreadStartExample();
        obj.data = 42;  // ① 主线程写
        
        Thread thread = new Thread(() -> {
            int x = obj.data;  // ③ 子线程读
            // x 一定等于 42 ✅
        });
        
        thread.start();  // ② start() 操作
    }
}

// happens-before 链：
// ① happens-before ②（程序顺序规则）
// ② happens-before ③（线程启动规则）
// 结论：① happens-before ③

规则 5：线程终止规则（Thread Termination Rule）

定义：线程的所有操作 happens-before 其他线程检测到该线程终止（join() 返回）。

public class ThreadJoinExample {
    private int data = 0;
    
    public static void main(String[] args) throws InterruptedException {
        ThreadJoinExample obj = new ThreadJoinExample();
        
        Thread thread = new Thread(() -> {
            obj.data = 42;  // ① 子线程写
        });
        
        thread.start();
        thread.join();  // ② 等待子线程结束
        
        int x = obj.data;  // ③ 主线程读
        // x 一定等于 42 ✅
    }
}

// happens-before 链：
// ① happens-before ②（线程终止规则）
// ② happens-before ③（程序顺序规则）
// 结论：① happens-before ③

规则 6：线程中断规则（Thread Interruption Rule）

定义：对线程 interrupt() 的调用 happens-before 被中断线程检测到中断事件。

public class InterruptExample {
    private int data = 0;
    
    public static void main(String[] args) throws InterruptedException {
        InterruptExample obj = new InterruptExample();
        
        Thread thread = new Thread(() -> {
            while (!Thread.currentThread().isInterrupted()) {
                // 工作中...
            }
            int x = obj.data;  // ③ 读取
            // x 一定能看到主线程的修改 ✅
        });
        
        thread.start();
        obj.data = 42;  // ① 主线程写
        thread.interrupt();  // ② 中断
    }
}

// happens-before 链：
// ① happens-before ②（程序顺序规则）
// ② happens-before ③（线程中断规则）
// 结论：① happens-before ③

规则 7：对象终结规则（Finalizer Rule）

定义：对象的构造函数结束 happens-before finalize() 方法的开始。

public class FinalizerExample {
    private int data;
    
    public FinalizerExample() {
        data = 42;  // ① 构造函数
    }  // ② 构造结束
    
    @Override
    protected void finalize() {  // ③ finalize 开始
        int x = data;  // ④ 读取
        // x 一定等于 42 ✅
    }
}

// happens-before 链：
// ① happens-before ②（程序顺序规则）
// ② happens-before ③（对象终结规则）
// ③ happens-before ④（程序顺序规则）

⚠️ 注意：finalize() 已被废弃（JDK 9+），不推荐使用。

规则 8：传递性规则（Transitivity）

定义：如果 A happens-before B，B happens-before C，则 A happens-before C。

public class TransitivityExample {
    private volatile boolean ready = false;
    private int data = 0;
    
    // 线程 A
    public void init() {
        data = 42;      // ① 写 data
        ready = true;   // ② volatile 写
    }
    
    // 线程 B
    public void use() {
        if (ready) {    // ③ volatile 读
            int x = data;  // ④ 读 data
            // x 一定等于 42 ✅
        }
    }
}

// happens-before 链：
// ① happens-before ②（程序顺序规则）
// ② happens-before ③（volatile 规则）
// ③ happens-before ④（程序顺序规则）
// 通过传递性：① happens-before ④ ✅

4.3 happens-before 与时间顺序的关系

⚠️ 重要：happens-before 不等于时间先后顺序！

int a = 1;  // ① 
int b = 2;  // ②

// ① happens-before ②（程序顺序规则）
// 但实际执行可能：② 先执行，① 后执行（重排序）
// 只要保证：如果 ② 依赖 ①，则 ① 的结果对 ② 可见

示例：允许重排序的情况

public class ReorderExample {
    private int a = 0;
    private int b = 0;
    
    public void method() {
        a = 1;  // ① 
        b = 2;  // ②
        int c = a + b;  // ③
    }
}

// happens-before 关系：
// ① happens-before ③
// ② happens-before ③
// 但 ① 和 ② 之间无 happens-before 关系 → 可以重排序

// 可能的执行顺序：
// b = 2; a = 1; int c = a + b;  ✅ 合法

五、volatile 关键字

5.1 volatile 的两大特性

特性	说明	示例
可见性	写操作立即刷新到主内存，读操作从主内存读取	状态标志
有序性	禁止指令重排序（内存屏障）	双重检查锁

⚠️ 不保证原子性：

private volatile int count = 0;

count++;  // ❌ 非原子操作（读-改-写）
// 等价于：
// int temp = count;  // 读
// temp = temp + 1;   // 改
// count = temp;      // 写
// 多线程下会丢失更新

5.2 volatile 的内存语义

写操作的内存语义

volatile boolean flag = false;

// 写操作：flag = true
1. 将当前线程工作内存中的所有变量刷新到主内存
2. 写入 flag = true 到主内存
3. 插入 StoreLoad 屏障（禁止后续读操作重排序到写之前）

读操作的内存语义

// 读操作：if (flag)
1. 插入 LoadLoad 屏障（禁止后续读操作重排序到 flag 读取之前）
2. 从主内存读取 flag 的最新值
3. 清空工作内存，后续读取从主内存加载

5.3 volatile 的内存屏障

四种内存屏障：

屏障类型	指令示例	说明
LoadLoad	Load1; LoadLoad; Load2	Load1 的数据必须先加载
StoreStore	Store1; StoreStore; Store2	Store1 的数据必须先刷新
LoadStore	Load1; LoadStore; Store2	Load1 必须先完成
StoreLoad	Store1; StoreLoad; Load2	Store1 必须全局可见后才能 Load2

volatile 写操作插入的屏障：

普通写/volatile 写
StoreStore 屏障  ← 禁止上面的写与 volatile 写重排序
volatile 写
StoreLoad 屏障   ← 禁止 volatile 写与下面的读重排序
普通读/volatile 读

volatile 读操作插入的屏障：

普通读/volatile 读
LoadLoad 屏障    ← 禁止下面的读与 volatile 读重排序
volatile 读
LoadStore 屏障   ← 禁止下面的写与 volatile 读重排序
普通写/volatile 写

5.4 volatile 的适用场景

✅ 场景 1：状态标志

public class StatusFlag {
    private volatile boolean shutdown = false;
    
    public void shutdown() {
        shutdown = true;  // 写线程
    }
    
    public void doWork() {
        while (!shutdown) {  // 读线程
            // 执行任务
        }
    }
}

✅ 场景 2：双重检查锁（DCL）

public class Singleton {
    private volatile static Singleton instance;
    
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

✅ 场景 3：独立观察（一写多读）

public class UserManager {
    private volatile User currentUser;
    
    // 写线程（单线程）
    public void updateUser(User user) {
        currentUser = user;
    }
    
    // 读线程（多线程）
    public User getCurrentUser() {
        return currentUser;
    }
}

❌ 场景 4：计数器（需要原子性）

public class Counter {
    private volatile int count = 0;
    
    public void increment() {
        count++;  // ❌ 非原子操作，会丢失更新
    }
    
    // 正确做法：
    private AtomicInteger count = new AtomicInteger(0);
    public void increment() {
        count.incrementAndGet();  // ✅ CAS 保证原子性
    }
}

5.5 volatile vs synchronized

对比项	volatile	synchronized
可见性	✅ 保证	✅ 保证
原子性	❌ 不保证	✅ 保证
有序性	✅ 保证（禁止重排序）	✅ 保证（锁机制）
性能	高（无锁）	低（加锁开销）
阻塞	不阻塞	阻塞
适用场景	状态标志、单次赋值	复合操作、临界区

六、final 关键字的内存语义

6.1 final 的三种使用场景

使用位置	说明	内存语义
final 变量	基本类型/引用类型	一次赋值，不可修改
final 方法	方法不可重写	无特殊内存语义
final 类	类不可继承	无特殊内存语义

本节重点讨论：final 域（成员变量）的内存语义

6.2 final 域的重排序规则

规则 1：final 域的写入重排序规则

定义：禁止将 final 域的写操作重排序到构造函数之外。

public class FinalExample {
    private final int x;
    private int y;
    private static FinalExample obj;
    
    public FinalExample() {
        x = 1;  // ① final 域写入
        y = 2;  // ② 普通域写入
    }  // ③ 构造函数结束
    
    public static void writer() {
        obj = new FinalExample();  // ④ 对象引用赋值
    }
    
    public static void reader() {
        FinalExample o = obj;  // ⑤ 读取引用
        int a = o.x;  // ⑥ 读取 final 域
        int b = o.y;  // ⑦ 读取普通域
    }
}

重排序分析：

// ✅ 允许的重排序（普通域）：
obj = new FinalExample();  // 先赋值引用
y = 2;                     // 后初始化 y（⚠️ 可能导致读到 0）

// ❌ 禁止的重排序（final 域）：
obj = new FinalExample();  // 先赋值引用
x = 1;                     // 后初始化 x（禁止！）

// 保证：如果读线程看到 obj != null，则 x 一定初始化完成

内存屏障实现（JVM 层面）：

构造函数：
    x = 1;  // final 域写入
    y = 2;  // 普通域写入
    StoreStore 屏障  ← 插入内存屏障
} // 构造函数结束
obj = new FinalExample();  // 对象引用赋值

规则 2：final 域的读取重排序规则

定义：禁止初次读取对象引用与读取 final 域重排序。

public static void reader() {
    FinalExample o = obj;  // ① 读取引用
    int a = o.x;           // ② 读取 final 域
}

// ❌ 禁止重排序为：
int a = o.x;           // 先读 x（此时 o 可能为 null）
FinalExample o = obj;  // 后读引用

内存屏障实现：

FinalExample o = obj;  // 读取引用
LoadLoad 屏障          ← 插入内存屏障
int a = o.x;           // 读取 final 域

6.3 final 引用类型的特殊规则

场景：final 域引用的对象

public class FinalReferenceExample {
    private final int[] arr;  // final 引用数组
    
    public FinalReferenceExample() {
        arr = new int[10];  // ① 分配数组
        arr[0] = 1;         // ② 初始化数组元素
    }
    
    private static FinalReferenceExample obj;
    
    public static void writer() {
        obj = new FinalReferenceExample();  // ③ 赋值引用
    }
    
    public static void reader() {
        FinalReferenceExample o = obj;  // ④ 读取引用
        int x = o.arr[0];  // ⑤ 读取数组元素
        // x 一定等于 1 ✅
    }
}

额外规则：

构造函数内对 final 引用对象的成员域的写入：
    arr = new int[10];
    arr[0] = 1;  ← 这个写入也受 final 保护
    StoreStore 屏障
} // 构造函数结束

// 保证：读线程看到 obj != null 时，arr[0] 一定初始化完成

⚠️ 注意：final 只保护构造函数内的初始化，不保护后续修改！

public class FinalMutableExample {
    private final List<String> list = new ArrayList<>();
    
    public FinalMutableExample() {
        list.add("A");  // ✅ 构造函数内，受保护
    }
    
    public void addElement(String s) {
        list.add(s);  // ❌ 构造函数外，不受 final 保护
        // 需要额外的同步机制
    }
}

6.4 final 的实际应用场景

应用 1：安全发布不可变对象

// 不使用 final（不安全）
public class UnsafePoint {
    private int x;
    private int y;
    
    public UnsafePoint(int x, int y) {
        this.x = x;
        this.y = y;
    }
}

// 问题：
Point p = new Point(1, 2);
// 另一个线程读取 p.x 可能读到 0（重排序导致）

// 使用 final（安全）
public class SafePoint {
    private final int x;  // ✅ final 保证可见性
    private final int y;
    
    public SafePoint(int x, int y) {
        this.x = x;
        this.y = y;
    }
}

// 保证：任何线程读取 p.x 一定读到 1

应用 2：String 类的不可变性

public final class String {
    private final char[] value;  // ✅ final 保证安全发布
    
    public String(String original) {
        this.value = original.value;
        // final 保证其他线程读取 value 一定是初始化后的
    }
}

// 优势：
// 1. 无需同步即可在多线程间共享
// 2. 可以安全地作为 HashMap 的 key
// 3. 字符串常量池优化

应用 3：享元模式（Flyweight）

public final class Integer {
    private final int value;  // ✅ final 不可变
    
    // 缓存 -128 到 127
    private static class IntegerCache {
        static final Integer[] cache = new Integer[256];
        static {
            for (int i = 0; i < cache.length; i++) {
                cache[i] = new Integer(i - 128);
            }
        }
    }
    
    public static Integer valueOf(int i) {
        if (i >= -128 && i <= 127) {
            return IntegerCache.cache[i + 128];  // 安全共享
        }
        return new Integer(i);
    }
}

6.5 final 与 volatile 的对比

对比项	final	volatile
可见性	✅ 构造函数完成后可见	✅ 每次读写都可见
原子性	N/A（不涉及修改）	❌ 不保证
有序性	✅ 禁止构造函数重排序	✅ 禁止读写重排序
修改	❌ 不可修改	✅ 可以修改
性能	最高（编译期优化）	高（无锁）
使用场景	不可变对象、常量	状态标志、单次赋值

七、实战案例

案例 1：单例模式的演进

版本 1：懒加载（线程不安全）

public class Singleton {
    private static Singleton instance;
    
    public static Singleton getInstance() {
        if (instance == null) {  // ❌ 多线程下会创建多个实例
            instance = new Singleton();
        }
        return instance;
    }
}

问题：

线程 A                          线程 B
──────────────────────────────────────────
if (instance == null) ✓
                                if (instance == null) ✓
instance = new Singleton();
                                instance = new Singleton();
// 创建了两个实例 ❌

版本 2：加锁（性能差）

public class Singleton {
    private static Singleton instance;
    
    public static synchronized Singleton getInstance() {  // ✅ 线程安全
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

问题：每次调用都要加锁，性能差（即使已经初始化）。

版本 3：双重检查锁（DCL，有问题）

public class Singleton {
    private static Singleton instance;  // ⚠️ 缺少 volatile
    
    public static Singleton getInstance() {
        if (instance == null) {  // 检查 1（无锁）
            synchronized (Singleton.class) {
                if (instance == null) {  // 检查 2（加锁）
                    instance = new Singleton();  // ⚠️ 问题代码
                }
            }
        }
        return instance;
    }
}

问题分析（重排序导致）：

// instance = new Singleton() 分解为：
1. memory = allocate();   // 分配内存
2. ctorInstance(memory);  // 初始化对象
3. instance = memory;     // 设置引用

// ⚠️ 可能重排序为：
1. memory = allocate();
3. instance = memory;     // 先设置引用（对象未初始化）
2. ctorInstance(memory);  // 后初始化

// 时序图：
线程 A                          线程 B
──────────────────────────────────────────
分配内存
instance = memory ────────→    if (instance == null) ✗
                               return instance; ⚠️ 半初始化对象
初始化对象（太晚了）

版本 4：DCL + volatile（正确）✅

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 禁止重排序
                }
            }
        }
        return instance;
    }
}

volatile 的作用：

// volatile 写操作会插入 StoreStore 屏障：
memory = allocate();
ctorInstance(memory);
StoreStore 屏障  ← 禁止上面的初始化与下面的引用赋值重排序
instance = memory;

// 保证：读线程看到 instance != null 时，对象一定初始化完成

版本 5：静态内部类（推荐）✅

public class Singleton {
    private Singleton() {}
    
    private static class Holder {
        private static final Singleton INSTANCE = new Singleton();
    }
    
    public static Singleton getInstance() {
        return Holder.INSTANCE;  // 类加载时初始化，天然线程安全
    }
}

优势：

懒加载：Holder 类在 getInstance() 调用时才加载
线程安全：类加载由 JVM 保证同步
性能好：无锁

版本 6：枚举（最佳实践）✅

public enum Singleton {
    INSTANCE;
    
    public void doSomething() {
        // 业务方法
    }
}

// 使用：
Singleton.INSTANCE.doSomething();

优势：

天然单例（JVM 保证）
线程安全
防止反序列化破坏单例
防止反射攻击

案例 2：生产者-消费者模式（volatile 实现）

public class ProducerConsumer {
    private volatile boolean hasData = false;
    private int data;
    
    // 生产者
    public void produce(int value) {
        data = value;       // ① 写数据
        hasData = true;     // ② volatile 写
    }
    
    // 消费者
    public int consume() {
        while (!hasData) {  // ③ volatile 读
            // 自旋等待
        }
        int result = data;  // ④ 读数据
        hasData = false;
        return result;      // result 一定等于 value ✅
    }
}

// happens-before 链：
// ① happens-before ②（程序顺序规则）
// ② happens-before ③（volatile 规则）
// ③ happens-before ④（程序顺序规则）
// 结论：① happens-before ④（传递性）

案例 3：配置类的安全发布

// 不安全的发布
public class UnsafeConfig {
    private Map<String, String> config;

    public UnsafeConfig() {
        config = new HashMap<>();
        config.put("url", "http://example.com");
        config.put("timeout", "30");
    }

    // 问题：其他线程可能读到未初始化的 config 或部分初始化的 Map
}

// 安全发布（使用 final）
public class SafeConfig {
    private final Map<String, String> config;  // ✅ final 保证可见性

    public SafeConfig() {
        Map<String, String> temp = new HashMap<>();
        temp.put("url", "http://example.com");
        temp.put("timeout", "30");
        config = Collections.unmodifiableMap(temp);  // ✅ 不可变
    }

    public String getConfig(String key) {
        return config.get(key);  // 线程安全，无需同步
    }
}

// 保证：任何线程读取 config 时，Map 已完全初始化

案例 4：延迟初始化占位符（Holder）

public class ResourceFactory {
    // 重量级资源
    private static class ResourceHolder {
        static final Resource resource = new Resource();  // ✅ 类加载时初始化
    }
    
    public static Resource getResource() {
        return ResourceHolder.resource;  // 懒加载 + 线程安全
    }
}

// 类加载时序：
// 1. ResourceFactory 类加载
// 2. 首次调用 getResource() 时，触发 ResourceHolder 类加载
// 3. 初始化 static final resource（JVM 保证线程安全）

案例 5：volatile 数组问题（常见误区）

// ❌ 错误示例
public class VolatileArray {
    private volatile int[] arr = new int[10];
    
    public void writer() {
        arr[0] = 1;  // ⚠️ 数组元素的修改不受 volatile 保护
    }
    
    public int reader() {
        return arr[0];  // ⚠️ 可能读到旧值
    }
}

// 问题分析：
// volatile 只保证 arr 引用的可见性
// 不保证 arr[0] 元素的可见性

// ✅ 正确做法 1：使用 AtomicIntegerArray
public class AtomicArrayExample {
    private AtomicIntegerArray arr = new AtomicIntegerArray(10);
    
    public void writer() {
        arr.set(0, 1);  // ✅ 原子操作 + 可见性
    }
    
    public int reader() {
        return arr.get(0);  // ✅ 读取最新值
    }
}

// ✅ 正确做法 2：使用 synchronized
public class SyncArrayExample {
    private int[] arr = new int[10];
    
    public synchronized void writer() {
        arr[0] = 1;  // ✅ 锁保证可见性
    }
    
    public synchronized int reader() {
        return arr[0];  // ✅ 读取最新值
    }
}

八、面试高频问题

Q1：什么是 Java 内存模型（JMM）？

参考答案：

JMM 是 Java 虚拟机规范定义的一种内存模型，用于屏蔽各种硬件和操作系统的内存访问差异。

核心概念：

主内存：所有线程共享的内存区域
工作内存：每个线程私有的内存区域（CPU 缓存）
内存交互：定义了 8 种操作（read、load、use、assign、store、write、lock、unlock）

作用：

定义变量的访问规则
保证多线程环境下的内存可见性
规定指令重排序的边界（happens-before）

与 JVM 内存结构的区别：

JVM 内存结构：堆、栈、方法区等物理内存布局
JMM：线程间通信的抽象模型（规范）

Q2：什么是内存可见性问题？如何解决？

参考答案：

定义：一个线程修改了共享变量的值，其他线程不能立即看到修改后的值。

原因：

CPU 缓存架构：

线程 A（Core 0）      线程 B（Core 1）

    ↓                     ↓

  L1 Cache              L1 Cache

  flag=false            flag=false  ← 各自缓存

    └────────┬────────────┘

           L3 Cache

              ↓

         主内存 RAM

         flag=true

解决方案：

方案	使用场景	性能
volatile	状态标志、单次赋值	高
synchronized	需要原子性保证	低
Lock	复杂同步逻辑	中
Atomic 类	CAS 操作	中
final	不可变对象	极高

示例：

// 问题代码
private static boolean flag = false;

// 解决方案
private static volatile boolean flag = false;  // ✅

Q3：volatile 有什么作用？能保证原子性吗？

参考答案：

作用（两大特性）：

可见性：
- 写操作：立即刷新到主内存
- 读操作：从主内存读取最新值
有序性：
- 禁止指令重排序（通过内存屏障）
- 保证 volatile 变量前后的操作不会被重排序

不保证原子性：

private volatile int count = 0;

count++;  // ❌ 非原子操作
// 分解为：
// 1. temp = count;  (读)
// 2. temp = temp + 1;  (改)
// 3. count = temp;  (写)
// 多线程下会丢失更新

// 正确做法：
AtomicInteger count = new AtomicInteger(0);
count.incrementAndGet();  // ✅ CAS 保证原子性

内存屏障实现：

volatile 写：
    StoreStore 屏障
    volatile 写
    StoreLoad 屏障

volatile 读：
    LoadLoad 屏障
    volatile 读
    LoadStore 屏障

Q4：什么是重排序？为什么要重排序？

参考答案：

定义：编译器和处理器为了优化性能，对指令执行顺序进行调整。

三种重排序：

源代码
  ↓
1. 编译器优化重排序（javac/JIT）
  ↓
2. 指令级并行重排序（CPU 流水线）
  ↓
3. 内存系统重排序（缓存、写缓冲）
  ↓
最终执行顺序

为什么要重排序？

性能优化：充分利用 CPU 流水线、缓存
减少等待：避免等待慢速内存操作

限制条件：

as-if-serial：单线程内结果不变
数据依赖性：有依赖的操作不会重排序

示例：

int a = 1;  // ①
int b = 2;  // ②
int c = a + b;  // ③

// 允许重排序：① 和 ② 交换（无依赖）
// 禁止重排序：③ 不能移到 ① 或 ② 之前（有依赖）

多线程问题：

// 线程 A
x = 1;
flag = true;

// 线程 B
if (flag) {
    int y = x;  // 可能读到 x = 0（重排序导致）
}

Q5：什么是 happens-before 原则？

参考答案：

定义：JMM 定义的操作偏序关系，如果 A happens-before B，则 A 的结果对 B 可见。

核心作用：

程序员：只需遵循 happens-before 规则，无需理解底层重排序
JVM：在不违反 happens-before 的前提下，可以自由优化

八大规则：

规则	说明	示例
程序顺序	单线程内按代码顺序执行	`a=1; b=2;`
volatile 规则	volatile 写 happens-before 后续读	`flag = true;`
锁规则	解锁 happens-before 后续加锁	`synchronized`
线程启动	start() happens-before 线程操作	`thread.start();`
线程终止	线程操作 happens-before join() 返回	`thread.join();`
线程中断	interrupt() happens-before 检测中断	`thread.interrupt();`
对象终结	构造结束 happens-before finalize()	`finalize()`
传递性	A→B, B→C ⇒ A→C	传递链

示例：

private volatile boolean flag = false;
private int data = 0;

// 线程 A
public void writer() {
    data = 42;      // ① 
    flag = true;    // ② volatile 写
}

// 线程 B
public void reader() {
    if (flag) {     // ③ volatile 读
        int x = data;  // ④
        // x 一定等于 42 ✅
    }
}

// happens-before 链：
// ① → ②（程序顺序）
// ② → ③（volatile 规则）
// ③ → ④（程序顺序）
// 结论：① → ④（传递性）

Q6：双重检查锁（DCL）为什么要用 volatile？

参考答案：

问题代码：

public class Singleton {
    private static Singleton instance;  // ⚠️ 缺少 volatile
    
    public static Singleton getInstance() {
        if (instance == null) {  // 检查 1
            synchronized (Singleton.class) {
                if (instance == null) {  // 检查 2
                    instance = new Singleton();  // ⚠️ 问题代码
                }
            }
        }
        return instance;
    }
}

问题分析：

// instance = new Singleton() 分解为 3 步：
1. memory = allocate();   // 分配内存
2. ctorInstance(memory);  // 初始化对象
3. instance = memory;     // 设置引用

// ⚠️ 可能重排序为：
1. memory = allocate();
3. instance = memory;     // 先设置引用（对象未初始化）
2. ctorInstance(memory);  // 后初始化

// 导致：
线程 A 执行到步骤 3 后，instance != null
线程 B 执行检查 1，发现 instance != null，直接返回
线程 B 使用 instance（未初始化的对象）→ NPE

volatile 的作用：

private static volatile Singleton instance;  // ✅ 添加 volatile

// volatile 写操作插入 StoreStore 屏障：
memory = allocate();
ctorInstance(memory);
StoreStore 屏障  ← 禁止重排序
instance = memory;

// 保证：读线程看到 instance != null 时，对象一定初始化完成

时序图：

无 volatile：
线程 A                          线程 B
──────────────────────────────────────────
分配内存
instance = memory ────────→    if (instance == null) ✗
                               return instance; ⚠️ 未初始化
初始化对象（太晚了）

有 volatile：
线程 A                          线程 B
──────────────────────────────────────────
分配内存
初始化对象
内存屏障
instance = memory ────────→    if (instance == null) ✗
                               return instance; ✅ 已初始化

Q7：volatile 和 synchronized 有什么区别？

参考答案：

对比项	volatile	synchronized
可见性	✅ 保证	✅ 保证
原子性	❌ 不保证	✅ 保证
有序性	✅ 禁止重排序	✅ 锁机制保证
性能	高（无锁，轻量级）	低（加锁，重量级）
阻塞	不阻塞	阻塞
语义	变量级别	代码块/方法级别
锁升级	无	有（偏向锁→轻量级锁→重量级锁）

使用场景：

// volatile 适用场景：
// 1. 状态标志
private volatile boolean shutdown = false;

// 2. 单次赋值
private volatile User currentUser;

// 3. 独立观察（一写多读）
private volatile long lastUpdateTime;

// synchronized 适用场景：
// 1. 复合操作
public synchronized void increment() {
    count++;  // 读-改-写
}

// 2. 多个变量需要保证一致性
public synchronized void transfer(Account from, Account to, int amount) {
    from.balance -= amount;
    to.balance += amount;
}

// 3. 临界区保护
public void updateCache() {
    synchronized (lock) {
        cache.clear();
        cache.putAll(newData);
    }
}

Q8：final 关键字的内存语义是什么？

参考答案：

两大重排序规则：

final 域写入规则：
- 禁止将 final 域的写操作重排序到构造函数之外
- 保证：读线程看到对象引用时，final 域一定初始化完成
final 域读取规则：
- 禁止初次读取对象引用与读取 final 域重排序
- 保证：读取 final 域前，一定先读取对象引用

实现机制：

public class FinalExample {
    private final int x;
    private int y;
    
    public FinalExample() {
        x = 1;  // final 域写入
        y = 2;  // 普通域写入
        // 编译器在此处插入 StoreStore 屏障
    }  // 构造函数结束
    
    private static FinalExample obj;
    
    public static void writer() {
        obj = new FinalExample();  // 对象引用赋值
    }
    
    public static void reader() {
        FinalExample o = obj;  // 读取引用
        // 编译器在此处插入 LoadLoad 屏障
        int a = o.x;  // 读取 final 域，保证读到 1 ✅
        int b = o.y;  // 读取普通域，可能读到 0 ⚠️
    }
}

final 引用类型的特殊保护：

public class FinalReferenceExample {
    private final int[] arr;
    
    public FinalReferenceExample() {
        arr = new int[10];
        arr[0] = 1;  // ✅ 这个写入也受 final 保护
        // StoreStore 屏障
    }
    
    // 保证：读线程看到 arr != null 时，arr[0] 一定等于 1
}

典型应用：

// 不可变对象（String）
public final class String {
    private final char[] value;  // ✅ 安全发布
    
    public String(String original) {
        this.value = original.value;
        // 无需额外同步，final 保证可见性
    }
}

// 单例模式（静态内部类）
public class Singleton {
    private static class Holder {
        static final Singleton INSTANCE = new Singleton();  // ✅ 线程安全
    }
}

Q9：如何安全地发布对象？

参考答案：

不安全发布示例：

public class UnsafePublish {
    private Map<String, String> config;
    
    public UnsafePublish() {
        config = new HashMap<>();
        config.put("key", "value");
        // ⚠️ 另一个线程可能读到：
        // 1. config = null（未初始化）
        // 2. config != null，但 Map 为空（部分初始化）
    }
}

安全发布的四种方式：

方式 1：使用 final 关键字

public class SafePublish1 {
    private final Map<String, String> config;  // ✅ final 保证可见性
    
    public SafePublish1() {
        Map<String, String> temp = new HashMap<>();
        temp.put("key", "value");
        config = Collections.unmodifiableMap(temp);  // 不可变
    }
}

方式 2：使用 volatile 关键字

public class SafePublish2 {
    private volatile Map<String, String> config;  // ✅ volatile 保证可见性
    
    public void init() {
        Map<String, String> temp = new HashMap<>();
        temp.put("key", "value");
        config = temp;  // volatile 写
    }
}

方式 3：使用 synchronized 同步

public class SafePublish3 {
    private Map<String, String> config;
    
    public synchronized void init() {  // ✅ 锁保证可见性
        config = new HashMap<>();
        config.put("key", "value");
    }
    
    public synchronized Map<String, String> getConfig() {
        return config;
    }
}

方式 4：使用静态初始化器

public class SafePublish4 {
    // ✅ 类加载时初始化，JVM 保证线程安全
    private static final Map<String, String> config = new HashMap<>();
    
    static {
        config.put("key", "value");
    }
}

总结：

安全发布 = 对象完全初始化 + 引用对其他线程可见

实现方式：
1. final 域（构造函数内初始化）
2. volatile 变量
3. synchronized 保护
4. static 静态初始化
5. 使用并发容器（ConcurrentHashMap 等）

Q10：as-if-serial 和 happens-before 的区别是什么？

参考答案：

as-if-serial（单线程语义）

定义：无论如何重排序，单线程程序的执行结果不能改变。

作用范围：单线程

示例：

int a = 1;  // ①
int b = 2;  // ②
int c = a + b;  // ③

// as-if-serial 允许：
// ② ①  ③（交换 ① 和 ②，因为无依赖）
// ① ② ③（保持顺序）

// as-if-serial 禁止：
// ③ ① ②（③ 依赖 ① 和 ②，结果会改变）

关键点：

编译器和处理器遵循数据依赖性
只保证单线程语义正确
多线程下可能出现问题

happens-before（多线程语义）

定义：定义操作的偏序关系，保证多线程下的内存可见性。

作用范围：多线程

示例：

// 线程 A
x = 1;          // ①
flag = true;    // ② volatile 写

// 线程 B
if (flag) {     // ③ volatile 读
    int y = x;  // ④
}

// happens-before 规则保证：
// ① happens-before ②（程序顺序规则）
// ② happens-before ③（volatile 规则）
// ③ happens-before ④（程序顺序规则）
// 结论：① happens-before ④（y 一定读到 1）

对比表：

对比项	as-if-serial	happens-before
适用范围	单线程	多线程
保证内容	执行结果不变	内存可见性
重排序限制	只考虑数据依赖	考虑同步关系
典型场景	编译器优化	volatile、锁、线程操作

关系：

as-if-serial 是 happens-before 的基础（程序顺序规则）

happens-before 是 as-if-serial 在多线程下的扩展

九、总结与最佳实践

9.1 内存模型核心要点

JMM 三大特性：
┌─────────────────────────────────────┐
│ 1. 原子性（Atomicity）              │
│    - synchronized                    │
│    - Lock                            │
│    - Atomic 类                       │
├─────────────────────────────────────┤
│ 2. 可见性（Visibility）             │
│    - volatile                        │
│    - synchronized                    │
│    - final                           │
├─────────────────────────────────────┤
│ 3. 有序性（Ordering）               │
│    - happens-before 规则             │
│    - 内存屏障                        │
│    - volatile / synchronized         │
└─────────────────────────────────────┘

9.2 并发编程最佳实践

原则 1：优先使用不可变对象

// ✅ 推荐
public final class ImmutablePoint {
    private final int x;
    private final int y;
    public ImmutablePoint(int x, int y) {
        this.x = x;
        this.y = y;
    }
    
    // 无需同步，天然线程安全
    public int getX() { return x; }
    public int getY() { return y; }
    
    // 修改时返回新对象
    public ImmutablePoint move(int dx, int dy) {
        return new ImmutablePoint(x + dx, y + dy);
    }
}

// 优势：
// 1. 无需同步，性能最高
// 2. 可以安全地在多线程间共享
// 3. 可以作为 HashMap 的 key

原则 2：最小化同步范围

// ❌ 不推荐：同步整个方法
public synchronized void process(List<Task> tasks) {
    List<Task> validTasks = validate(tasks);  // 耗时操作
    for (Task task : validTasks) {
        execute(task);  // 耗时操作
    }
    updateStatus();  // 只有这一步需要同步
}

// ✅ 推荐：只同步必要的部分
public void process(List<Task> tasks) {
    List<Task> validTasks = validate(tasks);  // 不需要锁
    for (Task task : validTasks) {
        execute(task);  // 不需要锁
    }
    synchronized (this) {
        updateStatus();  // 只锁定关键区域
    }
}

原则 3：优先使用并发工具类

// ❌ 不推荐：手动同步
public class ManualSync {
    private final Map<String, User> cache = new HashMap<>();
    
    public synchronized void put(String key, User user) {
        cache.put(key, user);
    }
    
    public synchronized User get(String key) {
        return cache.get(key);
    }
}

// ✅ 推荐：使用 ConcurrentHashMap
public class ConcurrentSync {
    private final Map<String, User> cache = new ConcurrentHashMap<>();
    
    public void put(String key, User user) {
        cache.put(key, user);  // 内部使用分段锁，性能更高
    }
    
    public User get(String key) {
        return cache.get(key);  // 读操作无锁
    }
}

原则 4：避免在锁内调用外部方法

// ❌ 危险：锁内调用外部方法（可能死锁）
public class DangerousLock {
    private final Object lock = new Object();
    
    public void process(Callback callback) {
        synchronized (lock) {
            // ...
            callback.onComplete();  // ⚠️ 外部方法可能再次获取锁
        }
    }
}

// ✅ 安全：锁外调用外部方法
public class SafeLock {
    private final Object lock = new Object();
    
    public void process(Callback callback) {
        Object result;
        synchronized (lock) {
            result = doWork();  // 锁内只处理必要操作
        }
        callback.onComplete(result);  // 锁外调用回调
    }
}

原则 5：正确使用 volatile

// ✅ 适合使用 volatile 的场景

// 场景 1：状态标志
public class Server {
    private volatile boolean shutdown = false;
    
    public void shutdown() {
        shutdown = true;  // 单次赋值
    }
    
    public void run() {
        while (!shutdown) {  // 读取最新值
            processRequest();
        }
    }
}

// 场景 2：安全发布
public class ResourceManager {
    private volatile Resource resource;
    
    public void init() {
        Resource temp = new Resource();
        temp.load();  // 完全初始化
        resource = temp;  // volatile 写，安全发布
    }
}

// 场景 3：独立观察
public class Monitor {
    private volatile long lastUpdateTime;
    
    public void recordUpdate() {
        lastUpdateTime = System.currentTimeMillis();  // 单次写入
    }
    
    public boolean isStale() {
        return System.currentTimeMillis() - lastUpdateTime > TIMEOUT;
    }
}

// ❌ 不适合使用 volatile 的场景

// 场景 1：复合操作
private volatile int count = 0;

public void increment() {
    count++;  // ❌ 非原子操作，volatile 无法保证
}

// 正确做法：
private AtomicInteger count = new AtomicInteger(0);

public void increment() {
    count.incrementAndGet();  // ✅ CAS 原子操作
}

// 场景 2：多变量一致性
private volatile int x;
private volatile int y;

public void update(int newX, int newY) {
    x = newX;  // ❌ 两个变量的更新不是原子的
    y = newY;  // ⚠️ 读线程可能看到不一致的状态
}

// 正确做法：
private int x;
private int y;

public synchronized void update(int newX, int newY) {
    x = newX;  // ✅ 锁保证原子性和可见性
    y = newY;
}

9.3 常见并发错误及避免方法

错误 1：双重检查锁忘记 volatile

// ❌ 错误
public class Singleton {
    private static Singleton instance;
    
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();  // ⚠️ 重排序问题
                }
            }
        }
        return instance;
    }
}

// ✅ 正确
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();
                }
            }
        }
        return instance;
    }
}

错误 2：误用 volatile 数组

// ❌ 错误
public class VolatileArrayError {
    private volatile int[] arr = new int[10];
    
    public void update(int index, int value) {
        arr[index] = value;  // ⚠️ volatile 不保护数组元素
    }
}

// ✅ 正确方案 1：使用 AtomicIntegerArray
public class AtomicArrayCorrect {
    private AtomicIntegerArray arr = new AtomicIntegerArray(10);
    
    public void update(int index, int value) {
        arr.set(index, value);  // ✅ 原子操作
    }
}

// ✅ 正确方案 2：使用同步
public class SyncArrayCorrect {
    private int[] arr = new int[10];
    
    public synchronized void update(int index, int value) {
        arr[index] = value;  // ✅ 锁保护
    }
}

错误 3：读写不对称的同步

// ❌ 错误：写加锁，读不加锁
public class AsymmetricSync {
    private int value;
    
    public synchronized void setValue(int value) {
        this.value = value;  // ✅ 写加锁
    }
    
    public int getValue() {
        return value;  // ❌ 读不加锁，可能读到旧值
    }
}

// ✅ 正确方案 1：读写都加锁
public class SymmetricSync {
    private int value;
    
    public synchronized void setValue(int value) {
        this.value = value;
    }
    
    public synchronized int getValue() {
        return value;  // ✅ 读也加锁
    }
}

// ✅ 正确方案 2：使用 volatile
public class VolatileSync {
    private volatile int value;  // volatile 保证可见性
    
    public void setValue(int value) {
        this.value = value;  // 无需加锁
    }
    
    public int getValue() {
        return value;  // 无需加锁
    }
}

错误 4：final 变量引用可变对象

// ⚠️ 潜在问题
public class FinalMutable {
    private final List<String> list = new ArrayList<>();
    
    public FinalMutable() {
        list.add("A");  // ✅ 构造函数内，final 保护
    }
    
    public void addElement(String s) {
        list.add(s);  // ⚠️ 构造函数外修改，final 不保护
    }
    
    // 其他线程可能读到不一致的 list 状态
}

// ✅ 正确：使用不可变集合
public class FinalImmutable {
    private final List<String> list;
    
    public FinalImmutable() {
        List<String> temp = new ArrayList<>();
        temp.add("A");
        list = Collections.unmodifiableList(temp);  // 不可变
    }
    
    // list 完全线程安全
}

9.4 性能优化技巧

技巧 1：减少锁粒度

// ❌ 粗粒度锁
public class CoarseLock {
    private final Map<String, User> cache = new HashMap<>();
    
    public synchronized void put(String key, User user) {
        cache.put(key, user);  // 整个 Map 加锁
    }
}

// ✅ 细粒度锁（使用 ConcurrentHashMap）
public class FineLock {
    private final Map<String, User> cache = new ConcurrentHashMap<>();
    
    public void put(String key, User user) {
        cache.put(key, user);  // 只锁定对应的分段
    }
}

// 性能对比：
// 单线程：相差不大
// 多线程：ConcurrentHashMap 提升 3-5 倍

技巧 2：读写分离

// ✅ 使用 ReadWriteLock
public class ReadWriteCache {
    private final Map<String, User> cache = new HashMap<>();
    private final ReadWriteLock lock = new ReentrantReadWriteLock();
    
    public User get(String key) {
        lock.readLock().lock();  // 读锁（允许多个线程）
        try {
            return cache.get(key);
        } finally {
            lock.readLock().unlock();
        }
    }
    
    public void put(String key, User user) {
        lock.writeLock().lock();  // 写锁（独占）
        try {
            cache.put(key, user);
        } finally {
            lock.writeLock().unlock();
        }
    }
}

// 适用场景：读多写少（读写比 > 10:1）

技巧 3：使用局部变量

// ❌ 共享变量（需要同步）
public class SharedVariable {
    private StringBuilder buffer = new StringBuilder();
    
    public synchronized String process(List<String> data) {
        buffer.setLength(0);
        for (String s : data) {
            buffer.append(s);
        }
        return buffer.toString();
    }
}

// ✅ 局部变量（无需同步）
public class LocalVariable {
    public String process(List<String> data) {
        StringBuilder buffer = new StringBuilder();  // 线程私有
        for (String s : data) {
            buffer.append(s);
        }
        return buffer.toString();
    }
}

// 性能提升：10 倍以上（无锁竞争）

技巧 4：延迟初始化

// ✅ Holder 模式（推荐）
public class LazyInit {
    private static class Holder {
        static final Resource resource = new Resource();  // 类加载时初始化
    }
    
    public static Resource getResource() {
        return Holder.resource;  // 懒加载 + 线程安全 + 高性能
    }
}

// 优势：
// 1. 第一次调用时才初始化
// 2. JVM 保证线程安全
// 3. 无锁，性能极高

9.5 并发工具选择指南

┌─────────────────────────────────────────────────────┐
│           并发场景                工具选择            │
├─────────────────────────────────────────────────────┤
│ 状态标志                        volatile boolean     │
│ 计数器（低并发）                AtomicInteger        │
│ 计数器（高并发）                LongAdder            │
│ 单例模式                        静态内部类/枚举      │
│ 缓存                            ConcurrentHashMap    │
│ 队列                            ConcurrentLinkedQueue│
│ 阻塞队列                        BlockingQueue        │
│ 读多写少                        ReadWriteLock        │
│ 复杂同步                        Semaphore/CountDown  │
│ 线程池                          ThreadPoolExecutor   │
└─────────────────────────────────────────────────────┘

⬅️ 垃圾回收与GC算法 🏠 00-Java ➡️ java的优势