## 概述


在高并发编程中，我们常常需要对 **一组整数** 进行线程安全的操作，例如实现一个分片计数器、维护一个环形缓冲区的状态、或为多个任务槽位分配资源。如果为每个整数都创建一个独立的 `AtomicInteger`，会带来显著的对象开销和内存碎片。

为此，Java并发包（JUC）提供了 **`AtomicIntegerArray`** ——一个基于 **CAS**（Compare-And-Swap） 机制的无锁原子整数数组类。它将 `AtomicInteger` 的原子性能力，高效地扩展到了整个 `int[]` 数组上，允许对数组中的 **任意单个元素** 进行独立的、线程安全的原子操作。

本文将带你深入 `AtomicIntegerArray` 的源码核心，从其内部数组管理、索引检查、CAS操作原理，到其在 **AI Agent时代** 海量智能体协同、高性能指标收集等场景下的关键作用。

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


----

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


### 1.1 独立AtomicInteger的局限


```
// 不优雅且低效的方案
AtomicInteger[] counters = new AtomicInteger[10];
for (int i = 0; i < counters.length; i++) {
    counters[i] = new AtomicInteger(0);
}
```

- **问题**：
	- **对象开销大**：每个 `AtomicInteger` 都是一个独立的对象，包含对象头等元数据，在数组较大时（如数千个元素），内存占用急剧增加。
	- **缓存局部性差**：这些对象在堆上分散存储，不利于CPU缓存行的利用，可能导致性能下降。

- **后果**：在需要大量计数器的场景下（如分片计数、直方图统计），这种方案显得笨重且低效。


### 1.2 AtomicIntegerArray 的核心价值


`AtomicIntegerArray` 内部封装了一个普通的 `int[]` 数组，并通过底层的 **Unsafe** 或 **VarHandle** 直接对该数组的内存进行原子操作。

```
// 高效且简洁的方案
AtomicIntegerArray counters = new AtomicIntegerArray(10); // 内部只有一个int[]

// 对任意索引进行原子操作
counters.incrementAndGet(5); // 原子地对第6个元素+1
```

- **内存高效**：只创建一个 `AtomicIntegerArray` 对象和一个 `int[]`，内存布局紧凑，缓存友好。

- **操作独立**：数组中的每个元素都可以被独立地、并发地更新，互不影响，完美支持 **分片**（Sharding） 思想。


----

## 第二章：源码全景——数组与VarHandle的高效协作


### 2.1 内部状态：原生int数组


`AtomicIntegerArray` 的设计非常精巧，它将复杂性隐藏在内部，对外提供简洁的API。

```
public class AtomicIntegerArray implements java.io.Serializable {
    private static final long serialVersionUID = 2862133569453604235L;

    // JDK 9+ 使用 VarHandle 来操作数组元素
    private static final VarHandle AA
        = MethodHandles.arrayElementVarHandle(int[].class);

    private final int[] array; // 核心状态：一个普通的int数组

    public AtomicIntegerArray(int length) {
        array = new int[length];
    }

    public AtomicIntegerArray(int[] array) {
        // 注意：这里会复制传入的数组，保证内部状态不被外部修改
        this.array = array.clone();
    }
}
```

- **`array` 字段**：这是一个普通的 `int[]`，但所有对其元素的访问都通过 `VarHandle` 进行，从而获得原子性和 `volatile` 语义。

- **安全性**：构造函数会复制传入的数组，防止外部代码意外修改内部状态，保证了封装性。


### 2.2 核心操作：带索引的CAS


所有原子操作都需要指定一个 **数组索引**，然后对该索引位置的元素执行原子更新。

#### compareAndSet


这是最核心的方法。

```
public final boolean compareAndSet(int i, int expect, int update) {
    checkIndex(i); // 先进行边界检查
    return AA.compareAndSet(array, i, expect, update);
}

private void checkIndex(int i) {
    if (i < 0 || i >= array.length)
        throw new IndexOutOfBoundsException("index " + i);
}
```

- **原子语义**：仅当 `array[i]` 的值等于 `expect` 时，才将其原子地更新为 `update`。

- **边界检查**：每次操作前都会进行索引合法性检查，确保安全性。


#### getAndIncrement


经典的“获取并递增”操作，同样采用 **自旋重试** 模式。

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

public final int getAndAdd(int i, int delta) {
    int current;
    do {
        current = get(i); // 获取当前值
    } while (!compareAndSet(i, current, current + delta)); // CAS重试
    return current;
}
```


----

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


### 3.1 核心API概览


`AtomicIntegerArray` 的API是 `AtomicInteger` API的自然扩展，几乎所有方法都增加了一个 `int i`（索引）参数。


|方法|描述|
|:-:|:-:|
|`get(int i)` / `set(int i, int newValue)`|获取/设置指定索引的值|
|`getAndSet(int i, int newValue)`|原子地设置新值，并返回旧值|
|`compareAndSet(int i, int expect, int update)`|**基石方法**，CAS原子更新|
|`getAndIncrement(int i)` / `incrementAndGet(int i)`|原子递增|
|`getAndDecrement(int i)` / `decrementAndGet(int i)`|原子递减|
|`getAndAdd(int i, int delta)` / `addAndGet(int i, int delta)`|原子加法|

### 3.2 典型应用场景


#### （1）高性能分片计数器（Striped Counter）


这是 `AtomicIntegerArray` 最经典的应用，用于解决单个 `AtomicInteger` 在高并发下的瓶颈。

```
public class StripedCounter {
    private final AtomicIntegerArray counters;
    private final int mask;

    public StripedCounter(int stripes) {
        // 通常选择2的幂次方，便于用位运算取模
        int size = Integer.highestOneBit(stripes) << 1;
        this.counters = new AtomicIntegerArray(size);
        this.mask = size - 1;
    }

    public void increment() {
        int stripe = Thread.currentThread().hashCode() & mask;
        counters.incrementAndGet(stripe); // 线程被分配到不同的槽位
    }

    public long total() {
        long sum = 0;
        for (int i = 0; i < counters.length(); i++) {
            sum += counters.get(i); // 非原子求和，适用于最终一致性场景
        }
        return sum;
    }
}
```

- **优势**：通过将竞争分散到多个槽位，极大地提高了并发吞吐量。Java 8 引入的 `LongAdder` 内部正是采用了类似的分片思想。


#### （2）环形缓冲区（Ring Buffer）的生产者-消费者协调


在Disruptor等高性能队列模式中，`AtomicIntegerArray` 可用于管理多个消费者的消费进度。

```
// 假设有N个消费者
private final AtomicIntegerArray consumerSequences = new AtomicIntegerArray(N);

// 消费者i在处理完一个事件后更新自己的序列号
public void onEventProcessed(int consumerId, int sequence) {
    consumerSequences.set(consumerId, sequence);
}

// 生产者需要知道最慢的消费者位置，以避免覆盖未消费的数据
public int getMinConsumerSequence() {
    int min = Integer.MAX_VALUE;
    for (int i = 0; i < consumerSequences.length(); i++) {
        min = Math.min(min, consumerSequences.get(i));
    }
    return min;
}
```
#### （3）多维指标收集


在监控系统中，可以使用 `AtomicIntegerArray` 来高效地收集按不同维度（如HTTP状态码）分类的请求计数。

```
// 索引0: 2xx, 1: 3xx, 2: 4xx, 3: 5xx
private final AtomicIntegerArray statusCodeCounters = new AtomicIntegerArray(4);

public void recordStatusCode(int code) {
    int index = code / 100 - 2;
    if (index >= 0 && index < 4) {
        statusCodeCounters.incrementAndGet(index);
    }
}
```


----

## 第四章：AI Agent时代的并发新范式


在 **AI Agent** 架构中，系统由大量自治、并发运行的智能体组成。`AtomicIntegerArray` 在这种新范式下找到了更广阔的应用舞台。

### 4.1 大规模Agent群体的状态聚合


想象一个由成千上万个AI Agent组成的模拟环境，每个Agent被分配一个唯一的ID。我们需要实时统计处于不同状态（如“探索”、“战斗”、“休眠”）的Agent数量。


- **解决方案**：使用一个 `AtomicIntegerArray`，其中每个索引代表一种状态。当Agent切换状态时，它原子地递减旧状态计数，并递增新状态计数。


```
// 状态: 0=EXPLORING, 1=FIGHTING, 2=SLEEPING
AtomicIntegerArray agentStateCounts = new AtomicIntegerArray(3);

void changeState(Agent agent, int newState) {
    int oldState = agent.getState();
    agentStateCounts.decrementAndGet(oldState);
    agent.setState(newState);
    agentStateCounts.incrementAndGet(newState);
}
```

- **优势**：操作极其轻量，即使面对海量Agent的频繁状态切换，也能保持高吞吐。


### 4.2 资源池的无锁分配与回收


AI Agent系统通常需要管理共享资源池（如数据库连接、计算单元）。`AtomicIntegerArray` 可以用来实现一个高效的、无锁的资源位图。

```
// 每个bit代表一个资源是否被占用，这里简化为每个int代表一个资源槽
AtomicIntegerArray resourceSlots = new AtomicIntegerArray(MAX_RESOURCES);

boolean acquireResource(int slotId) {
    // 尝试将空闲(0)的槽位标记为已占用(1)
    return resourceSlots.compareAndSet(slotId, 0, 1);
}

void releaseResource(int slotId) {
    // 直接释放，无需CAS，因为只有持有者会释放
    resourceSlots.set(slotId, 0);
}
```
### 4.3 与虚拟线程（Virtual Threads）的协同


Project Loom的虚拟线程使得启动海量并发任务变得轻而易举。`AtomicIntegerArray` 的 **无阻塞** 特性使其成为虚拟线程环境下管理共享状态的理想选择。


- **零上下文切换**：CAS操作不会导致线程挂起，完美契合虚拟线程追求极致并发的设计目标。

- **内存效率**：在可能同时存在数百万个虚拟线程的系统中，`AtomicIntegerArray` 的紧凑内存布局至关重要，能有效控制整体内存占用。


----

## 结语：高效并行的原子基石


`AtomicIntegerArray` 以其 **内存高效**、**操作独立**、**无锁并发** 的特性，成为处理 **数组级原子整数操作** 的不二之选。它巧妙地平衡了性能、内存和易用性，是构建高性能并发系统的重要工具。

在 **AI Agent时代**，面对海量智能体协同、实时状态聚合和高效资源共享的挑战，`AtomicIntegerArray` 所提供的 **分片** 和 **无锁** 能力，正成为构建下一代高并发、低延迟智能系统的关键基石。理解并善用它，能让你的系统在并发的洪流中稳如泰山。

>**如果你觉得这篇文章让你对 `AtomicIntegerArray` 有了更深的理解，不妨点个关注！我是 jack.yang，一位专注于 Java 底层原理、云原生架构与高并发系统设计的技术博主。**
**🌟 关注我，你将获得：**
- **每周一篇** 深度源码解析，带你穿透框架迷雾，直击技术本质。
- **前沿技术追踪**，第一时间解读 AI Agent、云原生、JDK 新特性等领域的最佳实践。
- **实战经验分享**，从理论到落地，助你构建坚如磐石的生产系统。
**你的每一次点赞、收藏和关注，都是我持续创作高质量技术内容的最大动力！让我们一起，在技术的星辰大海中，不断探索，共同成长！**

在高并发编程中，我们常常需要对 一组整数 进行线程安全的操作，例如实现一个分片计数器、维护一个环形缓冲区的状态、或为多个任务槽位分配资源。如果为每个整数都创建一个独立的 AtomicInteger，会带来显著的对象开销和内存碎片。

Java源码详解：深入Java并发之AtomicIntegerArray全景式解析——无锁整数数组的高效并行与AI Agent时代的协同基石

编程语言

后端

算法

Java并发编程中的AtomicIntegerArray类，基于CAS机制实现线程安全的整数数组操作，有效避免独立AtomicInteger带来的内存开销问题。适用于分片计数器、环形缓冲区、资源池等高性能场景，尤其在AIAgent时代的大规模并发环境下，支持海量智能体状态聚合与无锁资源管理，提升系统吞吐和内存效率。

数据库

云原生

智能体

Agent

Java

2026采购季 | AI焕新·智启新局

llmsgw

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

EdgeOne AI 安全实战专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

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

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

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

社区新版编辑器体验调研

Java源码详解：深入Java并发之AtomicIntegerArray全景式解析——无锁整数数组的高效并行与AI Agent时代的协同基石-腾讯云开发者社区-腾讯云

Java源码详解：深入Java并发之AtomicIntegerArray全景式解析——无锁整数数组的高效并行与AI Agent时代的协同基石

Java源码详解：深入Java并发之AtomicIntegerArray全景式解析——无锁整数数组的高效并行与AI Agent时代的协同基石

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐