a++;

ldr r0, [r1]          /* 从内存读取 a 的值到 r0 */add r0, r0, #1        /* r0 = r0 + 1 */str r0, [r1]          /* 把 r0 写回内存 */

这三条指令，就是CPU眼里的「三步」。

这有什么问题？

单线程世界没问题。但在并发世界里，这就是世界崩塌的开始。

想象一下，现在有两个线程，线程A想把a加1，线程B也想把a加1。如果没有保护，理想中的执行顺序应该是这样的：

线程A走完三步（a变成了1）→ 线程B再走完三步（a变成了2）。最终a是2。

这很完美，谁也不干扰谁。但现实是残酷的，CPU的调度是随机的。真正的执行流程很可能是这样交错的：

线程A执行了第1步（读取a=0）

← 调度发生！切到线程B

线程B执行完了全部三步（把a设为了1）

← 调度切回线程A

线程A继续执行第2、3步（把a设为1）

结果是什么？ 线程B的工作白干了。最终a的值是1，而不是预期的2。

这就是竞争。它之所以会发生，是因为C语言里的「一步」，在机器层面变成了「三步」。这三步如果不打包在一起执行，谁插一脚进来，数据就乱了。

要解决这个问题，核心思路只有一个：把这三步强行捏合成一个不可分割的整体。这就是「原子操作」名字的由来——像原子一样不可再分，要么全做完，要么别做。

环境：基于Linux 7.0-rc4

原子整形操作：不是所有的int都能直接用

在内核里，你不能随便拿个int变量就开始原子操作。内核用了一个专门的结构体来承载这种「不可分割」的属性，叫atomic_t。

它在include/linux/types.h里的定义非常朴素：

typedefstruct {int __aligned(sizeof(int)) counter;} atomic_t;#define ATOMIC_INIT(i) { (i) }

为什么要包一层结构体，而不是直接用int？

这是为了强制类型检查，防止你一不小心把它当成普通整数传给了不支持原子的函数（比如++i这种C语言操作）。把它封装起来，就是在提醒使用者：「这玩意儿特殊，请走专用通道。」

而且，__aligned(sizeof(int))这个对齐修饰符也很重要。它确保原子变量总是按照int的大小对齐的，这对于某些架构的原子操作指令是必需的。

定义与初始化

怎么用？首先定义原子变量。

最简单的定义方式：

atomic_t a;  /* 定义一个原子变量 a */

通常我们在定义的时候就要给它赋个初值，这时候要用专用宏ATOMIC_INIT：

atomic_t b = ATOMIC_INIT(0);  /* 定义 b 并初始化为 0 */

在Linux 7.0中，你还可以使用新的初始化方式：

atomic_t c = ATOMIC_INIT(0);  /* 静态初始化 *//* 或者动态初始化 */atomic_set(&c, 0);  /* 运行时设置 */

常用操作 API

一旦你有了atomic_t变量，以后对它的所有读写改，都不能再直接用=号或++了，必须通过内核提供的函数表。

下面的表格请务必多看两眼，这是驱动开发的「高频词汇表」：

Linux 7.0新增：内存顺序变体

在Linux 7.0中，原子操作API有了一个重要的扩展：内存顺序变体。

这是为了支持更精细的内存屏障控制，特别是在ARM这样的弱内存序架构上。新的API带有后缀：

• _relaxed
   - 无序访问，性能最好
• _acquire
   - 获取语义，保证之后的操作不会被重排到前面
• _release
   - 释放语义，保证之前的操作不会被重排到后面
• 无后缀 - 完全有序，默认版本

例如：

/* 完全有序（默认） */int val = atomic_read(&v);/* 松散序（性能最好，但无顺序保证） */int val = atomic_read_relaxed(&v);/* 获取序 */int val = atomic_read_acquire(&v);/* 释放序 */atomic_set_release(&v, 10);

⚠️ 注意

对于大多数驱动代码，使用默认的完全有序版本就足够了。内存序优化是高级主题，只有在确实需要 squeezing out 性能时才考虑。

实战片段：引用计数管理

把这些串起来，代码段大概是这样的：

/* 定义并初始化原子变量 */atomic_t ref_count = ATOMIC_INIT(1);  /* 初始引用计数为1 *//* 获取引用 */voidget_ref(void) {atomic_inc(&ref_count);  /* 引用计数加1 */}/* 释放引用 */voidput_ref(void) {/* 如果这是最后一个引用，清理资源 */if (atomic_dec_and_test(&ref_count)) {/* ref_count减1后变成了0，释放资源 */        kfree(resource);        pr_info("Resource freed.\n");    }}/* 查询当前引用数 */intget_ref_count(void) {returnatomic_read(&ref_count);}

这背后的机制是：每个函数内部，都会通过CPU的特定指令（比如ARM的LDREX和STREX）确保「读—改—写」这三步在硬件层面被锁死，别的核不可能插进来。

原子位操作：对「标志位」的精准控制

除了整数计数，我们经常还需要操作某一位。比如设备状态里有一个标志位，表示「设备正忙」。这时候就需要原子位操作。

原子位操作不需要像atomic_t那样的特殊结构体，它是直接对内存地址下手的。你传给它一个内存地址（比如你的设备结构体里的某个成员），再传给它一个位号（第几位），它就能保证只操作那一位，而且绝不乱套。

常用 API

这里同样有一张高频表：

这里的「原来」二字是关键。

test_and_set_bit是实现「先到先得」逻辑的神器。两个线程都试着调用它去抢同一个标志位：

• 线程A调用test_and_set_bit(0, &addr)，因为原来是0，返回0，线程A知道「是我先抢到的」，并且把位变成了1
• 线程B随后调用，因为已经是1了，返回1，线程B知道「已经有人抢了」，只好放弃或等待

这其实就是一个最简单的「自旋锁」的原型。

实战片段：设备状态管理

/* 设备状态标志位定义 */#define DEVICE_BUSY 0   /* 第0位：设备忙标志 */#define DEVICE_ERROR 1  /* 第1位：设备错误标志 *//* 设备结构体 */structmy_device {unsignedlong flags;  /* 状态标志位 *//* ... 其他成员 ... */};/* 设备打开时检查忙标志 */intmy_device_open(struct my_device *dev) {/* 尝试设置BUSY位，如果返回1表示已经被设置了 */if (test_and_set_bit(DEVICE_BUSY, &dev->flags)) {/* 设备忙，返回错误 */return -EBUSY;    }/* 成功获取设备访问权 */return0;}/* 设备关闭时清除忙标志 */voidmy_device_close(struct my_device *dev) {    clear_bit(DEVICE_BUSY, &dev->flags);}/* 错误处理 */voidmy_device_error(struct my_device *dev) {    set_bit(DEVICE_ERROR, &dev->flags);}/* 检查错误状态 */intmy_device_check_error(struct my_device *dev) {return test_bit(DEVICE_ERROR, &dev->flags);}

64位原子操作：当32位不够用时

如果你在64位的SoC上跑内核（比如Cortex-A53），你可能需要处理64位整数。内核也提供了对应的atomic64_t结构体和一系列atomic64_xxx函数。

/* 定义64位原子变量 */atomic64_t counter64 = ATOMIC64_INIT(0);/* 使用方式与32位版本完全相同 */atomic64_inc(&counter64);atomic64_add(1000, &counter64);u64 val = atomic64_read(&counter64);

用法和32位版本一模一样，只是把int换成了long long。

不过，鉴于我们的板子是32位的Cortex-A7，用32位原子操作就够了。但知道有64位版本存在是好事，万一以后换板子了呢。

什么时候用原子操作，什么时候用锁？

原子操作是内核并发控制的基石。它虽然只能保护简单的整数或位，但在很多场景下（比如简单的引用计数、开关标志），它不仅够用，而且是性能最好的选择——因为它没有锁带来的上下文切换开销，CPU也不用在那空转。

但原子操作有它的局限：它只能保护「一个变量」。如果你的代码逻辑需要同时保护两个变量，或者需要保护一大段复杂的数据结构，原子操作就显得力不从心了。

决策树：

需要保护的是单个整数或位吗？├─ 是 → 可以用原子操作│  └─ 操作很简单（inc/dec/test_set）？│     └─ 是 → 优先用原子操作（性能最好）└─ 否 → 需要用锁（自旋锁或互斥体）

这一小节就到这里

原子操作是最轻量级的并发控制机制。当你只需要保护一个简单的计数器或标志位时，它是首选。

但记住它的局限性：只能保护单个变量。一旦你需要保护复杂的数据结构或一段逻辑代码，就需要升级到更重型的武器——锁。

下一节，我们要接触那个让CPU「忙等待」的自旋锁，以及那个让线程「睡大觉」的互斥体。它们会引入新的问题，但也会带来更强的控制力。

本章要点

1. 原子操作解决的是「读—改—写」不可分割的问题
   。在C语言里看似原子的一步操作，在CPU层面可能是多步。
2. atomic_t是专门的原子整数结构体
   ，不能直接用++或--操作，必须使用内核提供的API。
3. Linux 7.0新增了内存顺序变体
   （_relaxed、_acquire、_release），但大多数驱动用默认版本即可。
4. 原子位操作直接对内存地址操作
   ，常用于标志位管理。test_and_set_bit是实现简单锁的原型。
5. 原子操作的适用场景
   ：保护单个整数或位。复杂场景需要用锁。

相关阅读

1. 现代Qt开发教程（新手篇）1.15——正则与文本处理 - 相似度 100%