## 概述


在高并发编程中，对共享计数器（如请求计数、序列号生成、资源配额）的安全递增是一个基础且关键的需求。传统的 `volatile int` 变量虽能保证可见性，却无法保证 **“读-改-写”** 操作（如 `i++`）的原子性。为解决这一问题，Java并发包（JUC）提供了 **`AtomicInteger`** ——一个基于 **CAS**（Compare-And-Swap） 机制的无锁原子整数类。它以极低的开销，实现了对整数值的线程安全操作，是构建高性能、无锁并发系统的核心基石。

本文将带你深入 `AtomicInteger` 的源码核心，从其内部状态表示、CAS操作原理、核心API设计，到其在 **JDK 25** 引入的 **作用域值**（Scoped Values） 和 **虚拟线程**（Virtual Threads） 时代下的全新挑战与演进方向。

>**文章被收录于专栏**：[云时代Java开发：原理、实战与优化](https://cloud.tencent.com/developer/column/107394)


----

## 第一章：设计哲学——为何需要 AtomicInteger？


### 1.1 volatile int 的局限


```
// 危险！非原子操作
volatile int counter = 0;

// 线程A和B同时执行
counter++; // 实际上是: read -> increment -> write
```

- **问题**：`counter++` 是一个复合操作。即使 `counter` 是 `volatile`，也无法阻止两个线程同时读取到相同的值（例如0），各自加1后都写回1，导致最终结果丢失一次递增。

- **后果**：计数不准确，破坏业务逻辑。


### 1.2 AtomicInteger 的核心价值


`AtomicInteger` 通过硬件级别的 **CAS指令**，将上述复合操作变为一个 **不可分割的原子单元**：

```
// 安全！原子操作
AtomicInteger counter = new AtomicInteger(0);

// 任意线程
int newValue = counter.incrementAndGet(); // 原子地+1并返回新值
```

- **无锁**（Lock-Free）：不依赖操作系统互斥量，避免了昂贵的上下文切换和内核态切换开销；

- **高效**：在低至中等竞争下，性能远超 `synchronized` 或 `ReentrantLock`。


----

## 第二章：源码全景——从Unsafe到VarHandle的演进（JDK 25视角）


### 2.1 内部状态：volatile int


`AtomicInteger` 的内部实现简洁而高效：

```
public class AtomicInteger extends Number implements java.io.Serializable {
    private static final long serialVersionUID = 6214790243416807050L;
    
    // JDK 9之前：使用sun.misc.Unsafe
    // JDK 9之后：迁移到VarHandle，但内部仍可能使用Unsafe作为底层实现
    private static final VarHandle VALUE;
    static {
        try {
            VALUE = MethodHandles.lookup()
                .findVarHandle(AtomicInteger.class, "value", int.class);
        } catch (Exception e) {
            throw new Error(e);
        }
    }

    private volatile int value; // 核心状态

    public AtomicInteger(int initialValue) {
        value = initialValue;
    }
}
```

- **`value` 字段**：被声明为 `volatile`，确保了内存可见性；

- **`VarHandle`**：自 JDK 9 起，`AtomicInteger` 的公共 API 已全面迁移到 `java.lang.invoke.VarHandle`，这是一个更安全、更灵活的内存访问抽象层。但在 JDK 25 的底层实现中，`VarHandle` 通常仍会委托给 `jdk.internal.misc.Unsafe` 来执行最终的 CAS 指令。


### 2.2 核心操作：CAS 与 自旋重试


所有原子操作最终都依赖于 **比较并交换**（CAS） 这一原子原语。

#### compareAndSet


这是最核心的方法，也是其他方法的基础。

```
public final boolean compareAndSet(int expect, int update) {
    return VALUE.compareAndSet(this, expect, update);
    // 最终映射到CPU的CAS指令，如x86的cmpxchg
}
```

- **原子语义**：仅当内存中的值等于 `expect` 时，才将其更新为 `update`，并返回 `true`；否则返回 `false`。


#### getAndIncrement


经典的“获取并递增”操作，展示了 **自旋重试**（Spin-Retry） 模式。

```
public final int getAndIncrement() {
    return getAndAdd(1);
}

public final int getAndAdd(int delta) {
    int prev, next;
    do {
        prev = get(); // 获取当前值
        next = prev + delta;
    } while (!compareAndSet(prev, next)); // 尝试CAS更新，失败则重试
    return prev;
}
```

- **自旋重试**：这是一种典型的 **“乐观锁”** 策略。它假设冲突是罕见的，因此在发生冲突时选择重试，而不是立即阻塞线程。这在竞争不激烈时性能极高。


----

## 第三章：核心API与典型应用场景


### 3.1 核心API概览


|方法|描述|
|:-:|:-:|
|`get()` / `set(int)`|获取/设置值（`set`有`volatile`语义）|
|`getAndSet(int)`|原子地设置新值，并返回旧值|
|`compareAndSet(int, int)`|**基石方法**，CAS原子更新|
|`getAndIncrement()` / `incrementAndGet()`|原子递增|
|`getAndDecrement()` / `decrementAndGet()`|原子递减|
|`getAndAdd(int)` / `addAndGet(int)`|原子加法|
|`weakCompareAndSetPlain(...)`|弱化的CAS，在某些平台上可能虚假失败，但开销更低|

### 3.2 典型应用场景


#### （1）高性能计数器


```
// 请求计数器
private final AtomicInteger requestCounter = new AtomicInteger(0);

public void handleRequest() {
    int currentCount = requestCounter.incrementAndGet();
    log.info("Handled {} requests so far.", currentCount);
}
```
#### （2）序列号生成器


```
// 全局唯一ID生成器
private final AtomicInteger sequence = new AtomicInteger(0);

public String generateId() {
    return "ID-" + sequence.getAndIncrement();
}
```
#### （3）简单的信号量/配额控制


```
// 控制最多10个并发任务
private final AtomicInteger activeTasks = new AtomicInteger(0);
private static final int MAX_TASKS = 10;

public boolean tryStartTask() {
    for (;;) {
        int current = activeTasks.get();
        if (current >= MAX_TASKS) {
            return false; // 配额已满
        }
        if (activeTasks.compareAndSet(current, current + 1)) {
            return true; // 成功获取配额
        }
        // 否则重试
    }
}

public void finishTask() {
    activeTasks.decrementAndGet();
}
```


----

## 第四章：JDK 25时代的挑战与演进


JDK 25作为最新的长期支持（LTS）版本，其核心特性 **虚拟线程**（Project Loom）、**作用域值**（Scoped Values, JEP 506） 和 **结构化并发**（Structured Concurrency, JEP 505） 对传统的并发原语提出了新的要求。

### 4.1 虚拟线程（Virtual Threads）下的性能考量


虚拟线程允许开发者轻松创建数百万个并发任务。`AtomicInteger` 的 **无锁** 特性使其天然适合这种海量并发模型。


- **优势**：没有阻塞、没有上下文切换，完美契合虚拟线程的设计目标；

- **挑战**：在极端高竞争场景下（数百万线程同时争抢同一个 `AtomicInteger`），自旋重试可能导致 **活锁**（Livelock） 和 **CPU资源耗尽**。


**JDK 25的演进方向**：


- **自适应自旋**：JVM可以监控CAS失败率，动态调整自旋策略，甚至在检测到高竞争时短暂让出CPU（`Thread.yield()`）；

- **分片计数器**（Striped Counters）：虽然 `AtomicInteger` 本身不会改变，但JDK鼓励开发者使用更高层次的抽象，如 `LongAdder`（专为高并发计数优化，内部使用分片思想）。


### 4.2 作用域值（Scoped Values）与原子状态


`ScopedValue` 是JDK 25引入的用于替代 `ThreadLocal` 的新机制，旨在解决 `ThreadLocal` 在虚拟线程和线程池环境下的内存泄漏和性能问题。

**对 `AtomicInteger` 的影响**：


- **间接影响**：`AtomicInteger` 本身不直接使用 `ThreadLocal`，但许多基于它的高级组件（如自定义的线程上下文）可能会。`ScopedValue` 提供了一种更安全的方式来管理这些上下文，从而让整个系统更健壮。

- **组合模式**：未来可能会出现将 `AtomicInteger` 与 `ScopedValue` 结合使用的模式，例如，为每个作用域分配一个独立的原子计数器。


### 4.3 可观测性与诊断增强


JDK 25强调 **可观测性**（Observability）。未来的 `AtomicInteger` 可能会提供更丰富的诊断信息：


- **JFR事件**：Java Flight Recorder 可以自动记录高频率的CAS失败事件，帮助开发者定位热点竞争；

- **Metrics集成**：通过 `java.lang.management` 暴露MBean，提供 `casSuccessRate`, `averageRetryAttempts` 等指标，便于SRE团队进行监控。


### 4.4 内存布局与缓存行填充（@Contended）


为了防止 **伪共享**（False Sharing）——即多个CPU核心频繁修改位于同一缓存行的不同变量，导致缓存行在核心间无效化——JDK 8引入了 `@sun.misc.Contended` 注解。

**现状**：`AtomicInteger` 本身 **并未** 使用 `@Contended`。这是因为：


- 它被设计为一个通用工具，添加填充会浪费内存（如果用户将多个 `AtomicInteger` 放在一起，填充反而无效）；

- 用户可以在自己的类中，将 `AtomicInteger` 字段用 `@Contended` 标记，以解决特定的伪共享问题。


**JDK 25的思考**：随着NUMA架构和多核CPU的普及，JVM可能会提供更智能的、运行时的缓存行优化策略，而不仅仅是依赖静态注解。


----

## 结语：小而美的无锁基石


`AtomicInteger` 以其 **极致的简洁**、**高效的无锁实现**、**明确的语义**，成为 Java 并发工具箱中最常用、最可靠的组件之一。它虽不如 `ReentrantLock` 或 `StampedLock` 那般功能复杂，但在其适用的领域——**线程安全的整数操作**——它几乎是唯一且最优的选择。

在 **JDK 25** 引领的 **虚拟线程**、**结构化并发** 与 **云原生可观测性** 交织的新时代，`AtomicInteger` 的核心价值——**以最小代价保证整数状态的原子性**——依然坚如磐石。理解它，就是掌握了一种构建高效、可靠并发系统的底层思维。

>**你认为像 `AtomicInteger` 这样的原子类，在未来的并发编程中会扮演更重要的角色，还是会被更高层次的抽象（如 `LongAdder`）所取代？欢迎在评论区分享你的见解！如果觉得本文助你深入理解 `AtomicInteger`，记得点赞、收藏，并转发给团队伙伴——一起构建更强大、更高效的并发系统！**

在高并发编程中，对共享计数器（如请求计数、序列号生成、资源配额）的安全递增是一个基础且关键的需求。传统的 volatile int 变量虽能保证可见性，却无法保证 “读-改-写” 操作（如 i++）的原子性。为解决这一问题，Java并发包（JUC）提供了 AtomicInteger ——一个基于 CAS（Compare-And-Swap） 机制的无锁原子整数类。它以极低的开销，实现了对整数值的线程安全操作，是构建高性能、无锁并发系统的核心基石。

Java源码详解：深入Java并发之AtomicInteger全景式解析——无锁整数的精妙实现与JDK 25/26时代的演进

在高并发编程中，对共享计数器（如请求计数、序列号生成、资源配额）的安全递增是一个基础且关键的需求。传统的 volatile int 变量虽能保证可见性，却无法保证 “读-改-写” 操作（如 i++）的原子性。为解决这一问题，Java并发包（JUC）提供了 AtomicInteger ——一个基于 CAS（Compare-And-Swap） 机制的无锁原子整数类。它以极低的开销，实现了对整数值的线程

后端

编程语言

算法

Java并发编程中，AtomicInteger通过CAS无锁机制实现线程安全的整数操作，避免volatile变量原子性问题。适用于高并发计数器、序列号生成等场景，在JDK25虚拟线程时代仍具高性能优势，结合LongAdder分片优化应对更高并发挑战。

云原生

Java

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

EdgeOne AI 安全实战专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

Java源码详解：深入Java并发之AtomicInteger全景式解析——无锁整数的精妙实现与JDK 25/26时代的演进-腾讯云开发者社区-腾讯云

Java源码详解：深入Java并发之AtomicInteger全景式解析——无锁整数的精妙实现与JDK 25/26时代的演进

Java源码详解：深入Java并发之AtomicInteger全景式解析——无锁整数的精妙实现与JDK 25/26时代的演进

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐