什么是 Java 中的原子性、可见性和有序性？

本文链接：https://blog.youkuaiyun.com/qq_63553317/article/details/145917768

回答

在 Java 中，原子性（Atomicity）、可见性（Visibility） 和 有序性（Ordering） 是 Java 内存模型（JMM，Java Memory Model）定义的三大核心特性，用于描述多线程环境下内存操作的行为和一致性。它们是确保线程安全和正确并发编程的基础。以下是详细说明：

1. 原子性（Atomicity）

定义：
- 指一个操作或一组操作要么全部执行完成，要么完全不执行，不会被线程切换或中断打断成半完成状态。
JMM 中的原子性：
- JMM 保证基本数据类型（除 long 和 double 外的 32 位操作，如 int、boolean）的读写是原子的。
- 复合操作（如 i++）不是原子的，因为它包含读、修改、写三个步骤，可能被其他线程干扰。
保障方式：
- 使用锁（如 synchronized、ReentrantLock）或原子类（如 AtomicInteger）将非原子操作封装为原子操作。

示例：

public class AtomicityExample {
    private int counter = 0;

    public void increment() {
        counter++; // 非原子，可能导致数据不一致
    }

    public synchronized void syncIncrement() {
        counter++; // 原子操作
    }
}

未加锁时，两个线程同时执行 increment() 可能导致丢失更新。
加锁后，syncIncrement() 保证原子性。

2. 可见性（Visibility）

定义：
- 指一个线程修改了共享变量的值后，其他线程能够立即看到最新的值。
JMM 中的可见性问题：
- 每个线程有本地内存（CPU 缓存），可能缓存共享变量的副本。
- 未同步时，线程可能读取到旧值，导致数据不一致。
保障方式：
- volatile：写操作立即刷新到主内存，读操作从主内存读取。
- 锁：加锁确保写回主内存，解锁前刷新；加锁线程看到最新值。
- final：初始化后不可变，保证构造完成后的可见性。

示例：

public class VisibilityExample {
    private static boolean flag = false;

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            while (!flag) {
                // 可能无限循环
            }
            System.out.println("Flag changed");
        });
        Thread t2 = new Thread(() -> {
            flag = true; // 未同步，可能不可见
        });

        t1.start();
        t2.start();
        t1.join();
    }
}

加 volatile 修饰 flag，确保 t1 看到 t2 的修改：
```
private static volatile boolean flag = false;
```

3. 有序性（Ordering）

定义：
- 指线程内操作按程序代码顺序执行（单线程假象），但多线程间可能因指令重排（reordering）出现乱序。
JMM 中的有序性问题：
- 编译器和 CPU 可能调整指令顺序以优化性能。
- 未正确同步时，可能导致多线程观察到意外顺序。
保障方式：
- volatile：禁止相关指令重排。
- 锁：同步块内的操作按顺序执行，且对其他线程可见。
- happens-before 规则：定义操作间的顺序关系。

示例：

public class OrderingExample {
    private static int x = 0, y = 0;
    private static int a = 0, b = 0;

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            a = 1;
            x = b; // 可能看到 b=0
        });
        Thread t2 = new Thread(() -> {
            b = 1;
            y = a; // 可能看到 a=0
        });

        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("x=" + x + ", y=" + y); // 可能输出 x=0, y=0
    }
}

加 volatile 修饰 a 和 b，或用锁，确保有序性：
```
private static volatile int a = 0, b = 0;
```

与 JMM 的关系

JMM 的目标：
- 通过定义 happens-before 规则和内存操作规则，保障这三大特性。
工具支持：
- synchronized：保证原子性、可见性和有序性。
- volatile：保证可见性和有序性。
- 原子类：通过 CAS 保证原子性。
硬件映射：
- JMM 通过内存屏障（如 StoreLoad）将特性映射到硬件。

综合示例

import java.util.concurrent.atomic.AtomicInteger;

public class CombinedExample {
    private static volatile int value = 0;
    private static final AtomicInteger atomicValue = new AtomicInteger(0);
    private static final Object lock = new Object();

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            synchronized (lock) {
                value = 1; // 原子性
                atomicValue.incrementAndGet(); // 原子性
            }
        });
        Thread t2 = new Thread(() -> {
            synchronized (lock) {
                System.out.println("Value: " + value); // 可见性
                System.out.println("Atomic: " + atomicValue.get()); // 有序性
            }
        });

        t1.start();
        t2.start();
        t1.join();
        t2.join();
    }
}

输出：
```
Value: 1
Atomic: 1
```
分析：
- synchronized 保证原子性。
- volatile 和锁确保可见性。
- 同步块维持有序性。