Java 并发三大特性：原子性、可见性、有序性（附代码验证）

在Java并发编程领域，原子性、可见性、有序性是支撑程序正确运行的三大基石。许多并发Bug的根源，都可归结为这三大特性的破坏。本文将从概念本质出发，结合代码实例剖析问题产生的原因，并给出对应的解决方案，帮助大家夯实并发编程基础。

一、原子性：不可分割的“操作单元”

1.1 概念解析

原子性是指一个操作或一组操作，要么全部执行且执行过程中不会被任何因素打断，要么全部不执行。就像现实生活中“转账”，从A账户扣钱和给B账户加钱，必须同时成功或同时失败，否则就会出现资金异常。

在Java中，并非所有操作都是原子的。例如常见的i++操作，看似简单，实则包含三个步骤：读取i的当前值、将值加1、将结果写回内存。这三个步骤在并发环境下可能被拆分执行，从而破坏原子性。

1.2 代码验证：原子性问题复现

我们通过一个“多线程累加”案例来演示原子性被破坏的场景。创建10个线程，每个线程对共享变量count执行1000次累加操作，理论上最终结果应为10000。

public class AtomicityDemo {
    // 共享变量
    private static int count = 0;

    // 累加方法
    public static void increment() {
        count++; // 非原子操作
    }

    public static void main(String[] args) throws InterruptedException {
        // 创建10个线程
        Thread[] threads = new Thread[10];
        for (int i = 0; i < 10; i++) {
            threads[i] = new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    increment();
                }
            });
            threads[i].start();
        }

        // 等待所有线程执行完毕
        for (Thread thread : threads) {
            thread.join();
        }

        // 输出结果
        System.out.println("最终count值：" + count);
    }
}

运行结果往往小于10000，例如9876。原因是当多个线程同时执行count++时，会出现“读取-修改-写回”的交叉。比如线程A读取count为100，线程B也读取count为100，两者都加1后写回，最终count仅变为101，而非预期的102，导致累加结果失真。

1.3 解决方案

• 使用synchronized关键字：通过加锁保证同一时间只有一个线程能执行 increment 方法，从而将一组操作变为原子操作。

public static synchronized void increment() {
    count++;
}

• 使用原子类：Java.util.concurrent.atomic包提供了原子性的包装类，如AtomicInteger，其incrementAndGet方法通过CAS（比较并交换）机制实现原子操作，性能优于synchronized。

private static AtomicInteger count = new AtomicInteger(0);

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

修改后再次运行，结果稳定为10000，原子性得到保证。

二、可见性：线程间的“信息同步”

2.1 概念解析

可见性是指当一个线程修改了共享变量的值后，其他线程能够立即看到这个修改后的结果。在单核CPU时代，线程共享同一内存，可见性问题不突出；但在多核CPU环境下，每个CPU都有自己的高速缓存，线程操作共享变量时会先将变量加载到本地缓存，修改后再写回主内存。若其他线程仍从自己的本地缓存读取变量，就无法感知到修改，从而引发可见性问题。

2.2 代码验证：可见性问题复现

定义一个共享变量flag，主线程启动一个子线程，子线程循环判断flag是否为true，若为true则退出循环；主线程修改flag为true后，观察子线程是否能及时退出。

public class VisibilityDemo {
    // 共享变量，未加volatile
    private static boolean flag = false;

    public static void main(String[] args) throws InterruptedException {
        // 子线程：循环判断flag
        new Thread(() -> {
            System.out.println("子线程启动，开始等待flag变为true");
            while (!flag) {
                // 空循环
            }
            System.out.println("子线程感知到flag变化，退出循环");
        }).start();

        // 主线程休眠1秒，确保子线程已启动并进入循环
        Thread.sleep(1000);

        // 主线程修改flag的值
        flag = true;
        System.out.println("主线程已将flag设置为true");
    }
}

运行结果显示：主线程输出“主线程已将flag设置为true”后，子线程仍在无限循环，无法感知到flag的修改。原因是子线程启动时将flag加载到本地缓存，由于循环中没有强制刷新缓存的操作，即使主线程修改了主内存中的flag，子线程也一直读取本地缓存中的旧值（false），可见性被破坏。

2.3 解决方案

• 使用volatile关键字：volatile可以保证变量的可见性。当一个变量被volatile修饰后，线程修改该变量时会立即写回主内存，同时强制其他线程的本地缓存失效，后续读取该变量时必须从主内存重新加载，从而确保线程能获取到最新值。

// 用volatile修饰共享变量
private static volatile boolean flag = false;

• 使用synchronized或Lock：同步机制不仅保证原子性，也能保证可见性。因为进入同步块时，线程会清空本地缓存并从主内存读取最新值；退出同步块时，线程会将修改后的值写回主内存。

添加volatile后重新运行，子线程会立即感知到flag的变化并退出循环，可见性得到保证。

三、有序性：避免“指令重排”的陷阱

3.1 概念解析

有序性是指程序执行的顺序按照代码的先后顺序执行。但为了优化性能，编译器和CPU会对指令进行重新排序。在单线程环境下，指令重排不会影响执行结果；但在多线程环境下，无序的指令执行可能导致程序逻辑混乱。

典型的例子是“双重检查锁定”实现单例模式。若不处理有序性问题，可能会出现对象未初始化完成就被其他线程获取的情况。

3.2 代码验证：有序性问题复现

定义两个共享变量a和flag，子线程先给a赋值，再将flag设为true；主线程判断flag为true后，读取a的值。理论上主线程读取的a应为1，但指令重排可能导致结果异常。

public class OrderlinessDemo {
    private static int a = 0;
    private static boolean flag = false;

    // 子线程：给a赋值，再设置flag
    public static void write() {
        a = 1;          // 指令1
        flag = true;    // 指令2
    }

    // 主线程：判断flag，再读a
    public static void read() {
        if (flag) {     // 指令3
            System.out.println("主线程读取到a的值：" + a); // 可能输出0
        }
    }

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 10000; i++) {
            // 每次循环重置变量
            a = 0;
            flag = false;

            // 启动子线程执行write
            Thread writeThread = new Thread(OrderlinessDemo::write);
            // 启动主线程执行read
            Thread readThread = new Thread(OrderlinessDemo::read);

            writeThread.start();
            readThread.start();

            // 等待线程执行完毕
            writeThread.join();
            readThread.join();
        }
    }
}

运行过程中可能出现主线程输出“主线程读取到a的值：0”的情况。原因是编译器或CPU为了优化性能，可能将write方法中的指令1和指令2重排，变成先执行flag = true（指令2），再执行a = 1（指令1）。此时主线程判断flag为true并读取a时，a还未被赋值，从而得到0。

3.3 解决方案

• 使用volatile关键字：volatile可以禁止指令重排。当flag被volatile修饰后，指令1和指令2的执行顺序会被强制保证，即必须先完成a的赋值，再设置flag为true，从而避免主线程读取到未初始化的a值。

private static int a = 0;
private static volatile boolean flag = false;

• 使用同步机制：synchronized和Lock同样能保证有序性，因为同步块内的指令会被视为一个整体，不会被重排到同步块外部。

添加volatile后，主线程读取到的a值始终为1，有序性得到保证。

四、总结：三大特性的核心价值

原子性、可见性、有序性共同保障了Java并发程序的正确性：

• 原子性解决“操作被拆分”的问题，确保关键逻辑完整执行；

• 可见性解决“线程间信息隔离”的问题，确保变量修改及时同步；

• 有序性解决“指令乱序”的问题，确保程序执行逻辑符合预期。

在实际开发中，我们可以通过volatile、synchronized、Lock、原子类等工具来维护这三大特性。理解特性本质，掌握解决方法，才能在复杂的并发场景中规避Bug，写出高效且可靠的代码。

最后留一个思考：volatile能保证原子性吗？结合本文的i++案例，大家可以动手验证一下，深化对特性的理解。