Java线程安全中的原子性：原理、问题与解决方案

Felix

发布时间：2026-10-15| 6人浏览过

原创

在Java并发编程中，原子性是保证线程安全的基础。当多个线程同时操作共享资源时，若缺乏原子性保障，极易产生数据不一致。本文将通过实例演示非原子操作导致的计算错误，并深度解析基于`synchronized`的悲观锁方案与基于`CAS`的乐观锁原子类方案，剖析其底层逻辑与性能取舍。

何为原子性

原子性是指一个操作或一组操作在执行过程中不可被中断。一旦开始执行，要么全部完成，要么全部不执行，中间状态对外不可见。这与数据库事务管理中的原子性概念一脉相承。如果这一特性无法得到保证，程序在并发环境下就可能出现前后结果不一致的情况。

以经典的银行转账为例：甲向乙账户转账500元，这看似是一个动作，实则包含两个子操作：甲账户-500 和 乙账户+500。若这两个操作不具备原子性，且在执行过程中发生线程切换，可能导致甲扣款成功而乙未收款，或者乙收款成功但甲未扣款，从而引发资金异常。

区分原子操作与非原子操作

要理解原子性，需先识别哪些指令是原子的。以下Java代码片段展示了不同操作的原子性特征：

int a = 1; // (1)
int b = a; // (2)
a += b;    // (3)

(1) 赋值操作： 将常量 1 赋给变量 a。在JVM字节码层面，这通常对应单条指令，属于原子操作。
(2) 读取后赋值： 获取 a 的值，再将其赋给 b。这涉及读、写两步，若在此期间其他线程修改了 a，结果将不可预测，故为非原子操作。
(3) 复合运算： a += b 实际上拆解为：获取 b 值、获取 a 值、相加、将结果写回 a。四个步骤，明显非原子操作。

由此可见，原子操作即那些不可分割、连续执行的单一指令。

线程安全与原子性问题演示

下面通过一个具体的代码示例，展示缺乏原子性保护时，多线程计数任务的失效现象。

第1步：构建非原子计数测试

目的：验证多线程环境下自增操作（count++）的数据竞争问题。

public class Demo {
    public static void main(String[] args) {
        Temp task = new Temp();
        // 启动100条线程
        for (int i = 1; i <= 100 ; i++) {
            new Thread(task).start();
        }
    }
}

class Temp implements Runnable {
    private int count = 0;
    
    @Override
    public void run() {
        // 每个线程累加100次
        for (int i = 1; i <= 100; i++) {
            count++;
            System.out.println(Thread.currentThread().getName() + "::count====>>" + count);
        }
    }
}

第2步：分析执行失败原因

上述代码意图是让100个线程各执行100次自增，最终 count 应为10000。然而，运行结果往往小于预期值。其根本原因在于 count++ 并非原子操作：

线程A读取 count 当前值为97。
线程A准备将值加1变为98，但此时CPU时间片耗尽，线程A暂停。
线程B获得CPU，读取到的 count 依然是97。
线程B将97加1变为98，并提交回内存。
线程A恢复，将之前计算的98提交回内存，覆盖了线程B的结果。

这种“丢失更新”现象证明了程序不具备原子性，导致并发不安全。增加线程数量（如500条）会显著加剧该问题的可见度。

解决方法：从悲观锁到乐观锁

针对上述原子性问题，Java提供了两种主流的解决思路，分别代表了对并发的不同策略假设。

第1步：使用synchronized（悲观锁/阻塞同步）

原理： synchronized 关键字修饰的方法或代码块，强制同一时刻只允许一条线程进入临界区执行任务。其他试图进入的线程将被阻塞，直到持有锁的线程释放资源。

策略逻辑： 这是一种“悲观”的策略。程序默认假设每次操作共享资源时，都会遭遇其他线程的竞争和干扰。因此，它采取最保守的手段——互斥同步，直接剥夺其他线程的执行权。

优劣评价： 虽然能完美保证原子性和安全性，但由于频繁的线程阻塞与唤醒带来了巨大的上下文切换开销，在竞争激烈的场景下性能较低。

第2步：使用原子类（乐观锁/非阻塞同步）

为何引入： synchronized 的性能瓶颈促使开发者寻求更高效的方案。Java并发包（java.util.concurrent.atomic）提供了一系列原子类，如 AtomicInteger，它们利用无锁机制实现高性能的线程安全操作。

常用API： 以 AtomicInteger 为例：

import java.util.concurrent.atomic.AtomicInteger;

// 基本操作
public final int set(int newValue);           // 设置新值
public final int get();                       // 获取当前值
public final int getAndIncrement();           // 原子自增，返回旧值
public final int incrementAndGet();           // 原子自增，返回新值
public final boolean compareAndSet(int expect, int update); // 比较并替换

除了整型原子类，还有 AtomicLong、AtomicBoolean、AtomicReferenceArray 等多种类型，覆盖大多数基础数据类型的并发需求。