Java 多线程三大特性详解：原子性、可见性、有序性

🔍 底层原理

• Monitor 机制：每个 Java 对象关联一个 Monitor（C++ 实现），由 JVM 管理。
• 对象头 Mark Word：存储锁状态（无锁/偏向锁/轻量级锁/重量级锁）。
• 字节码指令：
  • monitorenter：进入同步块时获取锁；
  • monitorexit：退出时释放锁。
• 内存语义：进入/退出同步块时自动刷新工作内存 ↔ 主内存，同时保证可见性与有序性。

锁升级路径：

无锁 → 偏向锁（单线程优化） → 轻量级锁（自旋） → 重量级锁（OS 阻塞）

2. ReentrantLock —— 显式可重入锁

✅ 代码示例

import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockExample {
    private int count = 0;
    private final ReentrantLock lock = new ReentrantLock();

    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock(); // 必须在 finally 中释放
        }
    }

    public static void main(String[] args) throws InterruptedException {
        ReentrantLockExample e = new ReentrantLockExample();
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) e.increment();
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) e.increment();
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("Final count: " + e.count); // 输出 2000
    }
}

🔍 底层原理

• AQS（AbstractQueuedSynchronizer）：
  • 核心字段：volatile int state（锁状态）、Node head/tail（CLH 双向等待队列）。
• 加锁流程：
  1. CAS 尝试将 state 从 0 → 1；
  2. 失败则封装线程为 Node 入队，并调用 LockSupport.park() 阻塞；
• 解锁流程：
  1. CAS 将 state 减 1；
  2. 唤醒队列头节点（LockSupport.unpark()）。
• 可重入性：记录当前持有线程，同一线程可多次加锁（state 递增）。
• 优势：支持公平锁、超时、可中断、多条件变量（Condition）。

3. 原子类（如 AtomicInteger）

✅ 代码示例

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicExample {
    private AtomicInteger count = new AtomicInteger(0);

    public void increment() {
        count.incrementAndGet(); // 原子自增
    }

    public static void main(String[] args) throws InterruptedException {
        AtomicExample e = new AtomicExample();
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) e.increment();
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) e.increment();
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("Final count: " + e.count.get()); // 输出 2000
    }
}

🔍 底层原理

• Unsafe 类：调用 native 方法 compareAndSwapInt()，利用 CPU 原子指令（如 x86 的 LOCK CMPXCHG）。
• 无锁并发：失败则自旋重试，避免线程阻塞开销。
• volatile 修饰：内部字段 private volatile int value，天然具备可见性与部分有序性。
• ABA 问题：可通过 AtomicStampedReference 解决。

CAS（Compare-And-Swap）：

public final int incrementAndGet() {
    return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
}

4. StampedLock —— 乐观读写锁

✅ 代码示例

import java.util.concurrent.locks.StampedLock;

public class StampedLockExample {
    private double x = 0, y = 0;
    private final StampedLock sl = new StampedLock();

    void move(double dx, double dy) {
        long stamp = sl.writeLock();
        try {
            x += dx;
            y += dy;
        } finally {
            sl.unlockWrite(stamp);
        }
    }

    double distanceFromOrigin() {
        long stamp = sl.tryOptimisticRead(); // 乐观读
        double currentX = x, currentY = y;
        if (!sl.validate(stamp)) { // 检查是否被写入
            stamp = sl.readLock(); // 升级为悲观读
            try {
                currentX = x;
                currentY = y;
            } finally {
                sl.unlockRead(stamp);
            }
        }
        return Math.sqrt(currentX * currentX + currentY * currentY);
    }

    public static void main(String[] args) {
        StampedLockExample obj = new StampedLockExample();
        obj.move(3, 4);
        System.out.println("Distance: " + obj.distanceFromOrigin()); // 输出 5.0
    }
}

🔍 底层原理

• 改进型 AQS：使用 long stamp 代替 int state，低 7 位表示锁模式，高位为版本号。
• 乐观读：
  • 不加锁，仅记录版本号；
  • 读取后验证版本是否变化（validate(stamp)）；
  • 若未被写入，则读成功；否则升级为悲观读。
• 写锁与读锁互斥，但多个乐观读可并发。
• 不支持重入，且无条件变量。
• 适用场景：读远多于写的高性能计算（如几何坐标计算）。

四、可见性（Visibility）

1. volatile —— 轻量级可见性保障

✅ 代码示例

public class VolatileVisibilityExample {
    private volatile boolean running = true; // volatile 保证可见性

    public void stop() {
        running = false;
    }

    public void runTask() {
        while (running) {
            System.out.println("Working...");
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                break;
            }
        }
        System.out.println("Task stopped.");
    }

    public static void main(String[] args) throws InterruptedException {
        VolatileVisibilityExample task = new VolatileVisibilityExample();
        Thread worker = new Thread(task::runTask);
        worker.start();
        Thread.sleep(2000);
        task.stop(); // 主线程停止任务
        worker.join();
    }
}

❗ 若去掉 volatile，worker 线程可能永远看不到 running = false，导致死循环。

🔍 底层原理

• JMM 内存语义：
  • 写 volatile：立即刷回主内存，并使其他 CPU 缓存行失效；
  • 读 volatile：从主内存重新加载最新值。
• 内存屏障（Memory Barrier）：
  • 写屏障：StoreStore + StoreLoad，禁止写之前的操作重排到写之后；
  • 读屏障：LoadLoad + LoadStore，禁止读之后的操作重排到读之前。
• 缓存一致性协议：如 MESI 协议，确保多核 CPU 缓存一致性。
• 不保证原子性：如 i++ 仍需锁或原子类。

2. synchronized 保证可见性

✅ 代码示例（复用前文 SynchronizedExample）

🔍 底层原理

• happens-before 规则：解锁 happens-before 后续加锁。
• 内存同步：
  • 进入同步块：清空工作内存，从主内存重新加载共享变量；
  • 退出同步块：将修改后的共享变量 flush 到主内存。
• 底层通过 Monitor 的 entry/exit 操作触发内存同步。

3. final 字段的可见性

✅ 代码示例

public class FinalFieldExample {
    private final int x;
    private final int y;

    public FinalFieldExample(int x, int y) {
        this.x = x;
        this.y = y; // 构造完成后对所有线程可见
    }

    public int sum() {
        return x + y; // 无需同步，安全
    }

    public static void main(String[] args) {
        FinalFieldExample obj = new FinalFieldExample(3, 4);
        new Thread(() -> {
            System.out.println("Sum in thread: " + obj.sum()); // 输出 7
        }).start();
    }
}

🔍 底层原理

• JLS §17.5 final 语义：
  • 构造函数内对 final 字段的写操作，不会被重排到构造函数之外；
  • 构造完成后，final 字段的值对所有线程立即可见。
• 安全发布：只要对象正确构造（未逸出），final 字段无需同步即可安全读取。
• 适用场景：构建不可变对象（Immutable Object）。

五、有序性（Ordering）

1. volatile 禁止重排序（DCL 单例）

✅ 代码示例

public class DoubleCheckedLockingSingleton {
    // 必须加 volatile！否则可能返回未完全初始化的对象
    private volatile static DoubleCheckedLockingSingleton instance;

    private DoubleCheckedLockingSingleton() {}

    public static DoubleCheckedLockingSingleton getInstance() {
        if (instance == null) {
            synchronized (DoubleCheckedLockingSingleton.class) {
                if (instance == null) {
                    instance = new DoubleCheckedLockingSingleton(); // 关键：防止重排序
                }
            }
        }
        return instance;
    }

    public void doSomething() {
        System.out.println("Singleton working...");
    }

    public static void main(String[] args) {
        DoubleCheckedLockingSingleton s1 = getInstance();
        DoubleCheckedLockingSingleton s2 = getInstance();
        System.out.println(s1 == s2); // true
        s1.doSomething();
    }
}

🔍 底层原理

• 对象创建三步骤：
  1. 分配内存空间；
  2. 初始化对象；
  3. 将 instance 指向内存地址。
• 重排序风险：步骤 2 与 3 可能重排为 1 → 3 → 2，导致其他线程拿到未初始化对象。
• volatile 作用：
  • 在 instance = new ... 写操作后插入 StoreStore 屏障；
  • 确保初始化完成后再赋值引用。
• happens-before：volatile 写 happens-before 后续 volatile 读。

2. synchronized 保证有序性

✅ 代码示例（复用前文）

🔍 底层原理

• 程序顺序规则：同步块内部代码按程序顺序执行。
• 监视器锁规则：解锁 happens-before 后续加锁，建立跨线程顺序。
• 底层 Monitor 机制隐含内存屏障，禁止临界区内外的操作重排。

六、综合对比表

七、最佳实践建议

• 状态标志 → volatile boolean flag
• 计数器/累加器 → AtomicInteger 或 LongAdder（高并发分段累加）
• 复合操作（如转账） → synchronized（简单）或 ReentrantLock（灵活）
• 高性能读多写少 → StampedLock
• 不可变对象 → final 字段 + 构造函数安全初始化
• 避免过度同步：锁粒度越小越好，优先无锁方案

八、附录：关键概念速查

💡 口诀记忆：原（原子性）可（可见性）有（有序性）——Java 并发三基石。