原子操作实战指南：Linux内核7.0最轻量的并发控制
前言：为什么简单的a = 3并不简单
上一节我们花了很大力气去识别「谁是危险分子」。一旦你找到了那个需要保护的共享变量——比如一个记录设备打开次数的全局计数器——你面临的第一道防线就是原子操作。
它是内核中最轻量级的保护机制，轻到有时候你甚至感觉不到它的存在，但它解决的却是并发世界里最本质的崩坏问题：「读取—修改—写入」这三步，绝对不能被打断。
老实说，我在刚开始写驱动的时候，对这个概念是完全不理解的。我当时想：「不就是个计数器吗？counter++能有什么问题？」
然后我就收获了人生中第一个Kernel Panic。然后打开日志一看——不是哥们，怎么这些值变得面目全非的？？？后来知道了——啊哈，并发是你干的！
从C语言到汇编：理解为什么a++不是原子的
先抛开内核的术语，我们从最直觉的一个误解开始。
在C语言里，给变量加1是天经地义的：
a++;这一行代码在你眼里是不可分割的一步。但在CPU眼里，它不是。
绝大多数现代架构（包括我们用的ARM）都不能直接对内存变量进行自增操作。这事儿必须通过寄存器中转。假设变量a存放在内存地址0x30000000，编译器把上面那行优雅的C语言编译成汇编后，实际上变成了三件事：
- 把变量
a的值从内存读入寄存器r0 - 在寄存器
r0里加1 - 把
r0的值写回内存地址
对应的ARM汇编代码大概长这样：
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
| 项目 | 版本/信息 |
|---|---|
| 内核版本 | Linux 7.0-rc4 (主线内核) |
| 架构 | ARMv7-A |
| 相关头文件 | include/linux/atomic.h |
原子整形操作：不是所有的int都能直接用
在内核里，你不能随便拿个int变量就开始原子操作。内核用了一个专门的结构体来承载这种「不可分割」的属性，叫atomic_t。
它在include/linux/types.h里的定义非常朴素：
typedef struct {
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变量，以后对它的所有读写改，都不能再直接用=号或++了，必须通过内核提供的函数表。
下面的表格请务必多看两眼，这是驱动开发的「高频词汇表」：
| 函数 | 描述 |
|---|---|
ATOMIC_INIT(int i) | 初始化宏，定义原子变量时用它来赋初值 |
int atomic_read(atomic_t *v) | 读：读取v的值并返回 |
void atomic_set(atomic_t *v, int i) | 写：向v写入i值（注意，这本身是原子的） |
void atomic_add(int i, atomic_t *v) | 加：给v加上i |
void atomic_sub(int i, atomic_t *v) | 减：从v减去i |
void atomic_inc(atomic_t *v) | 自增：给v加1（相当于i++） |
void atomic_dec(atomic_t *v) | 自减：从v减1（相当于i--） |
int atomic_dec_return(atomic_t *v) | 减并返回：v减1，并且返回新值 |
int atomic_inc_return(atomic_t *v) | 加并返回：v加1，并且返回新值 |
int atomic_sub_and_test(int i, atomic_t *v) | 减并测试：v减i，如果结果为0返回真，否则假 |
int atomic_dec_and_test(atomic_t *v) | 减一并测试：v减1，如果结果为0返回真（常用于引用计数归零检测） |
int atomic_inc_and_test(atomic_t *v) | 加一并测试：v加1，如果结果为0返回真（极少用） |
int atomic_add_negative(int i, atomic_t *v) | 加并测负：v加i，如果结果是负数返回真 |
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 */
/* 获取引用 */
void get_ref(void) {
atomic_inc(&ref_count); /* 引用计数加1 */
}
/* 释放引用 */
void put_ref(void) {
/* 如果这是最后一个引用，清理资源 */
if (atomic_dec_and_test(&ref_count)) {
/* ref_count减1后变成了0，释放资源 */
kfree(resource);
pr_info("Resource freed.\n");
}
}
/* 查询当前引用数 */
int get_ref_count(void) {
return atomic_read(&ref_count);
}这背后的机制是：每个函数内部，都会通过CPU的特定指令（比如ARM的LDREX和STREX）确保「读—改—写」这三步在硬件层面被锁死，别的核不可能插进来。
原子位操作：对「标志位」的精准控制
除了整数计数，我们经常还需要操作某一位。比如设备状态里有一个标志位，表示「设备正忙」。这时候就需要原子位操作。
原子位操作不需要像atomic_t那样的特殊结构体，它是直接对内存地址下手的。你传给它一个内存地址（比如你的设备结构体里的某个成员），再传给它一个位号（第几位），它就能保证只操作那一位，而且绝不乱套。
常用 API
这里同样有一张高频表：
| 函数 | 描述 |
|---|---|
void set_bit(int nr, void *p) | 置位：将地址p的第nr位设置为1 |
void clear_bit(int nr, void *p) | 清零：将地址p的第nr位清零 |
void change_bit(int nr, void *p) | 翻转：将地址p的第nr位取反（0变1，1变0） |
int test_bit(int nr, void *p) | 测试：读取第nr位的值（非原子读，仅用于查询） |
int test_and_set_bit(int nr, void *p) | 测并置位：原子地设置第nr位为1，并返回它原来的值（常用于加锁） |
int test_and_clear_bit(int nr, void *p) | 测并清零：原子地清除第nr位，并返回它原来的值 |
int test_and_change_bit(int nr, void *p) | 测并翻转：原子地翻转第nr位，并返回它原来的值 |
这里的「原来」二字是关键。
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位：设备错误标志 */
/* 设备结构体 */
struct my_device {
unsigned long flags; /* 状态标志位 */
/* ... 其他成员 ... */
};
/* 设备打开时检查忙标志 */
int my_device_open(struct my_device *dev) {
/* 尝试设置BUSY位，如果返回1表示已经被设置了 */
if (test_and_set_bit(DEVICE_BUSY, &dev->flags)) {
/* 设备忙，返回错误 */
return -EBUSY;
}
/* 成功获取设备访问权 */
return 0;
}
/* 设备关闭时清除忙标志 */
void my_device_close(struct my_device *dev) {
clear_bit(DEVICE_BUSY, &dev->flags);
}
/* 错误处理 */
void my_device_error(struct my_device *dev) {
set_bit(DEVICE_ERROR, &dev->flags);
}
/* 检查错误状态 */
int my_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「忙等待」的自旋锁，以及那个让线程「睡大觉」的互斥体。它们会引入新的问题，但也会带来更强的控制力。
本章要点
- 原子操作解决的是「读—改—写」不可分割的问题。在C语言里看似原子的一步操作，在CPU层面可能是多步。
atomic_t是专门的原子整数结构体，不能直接用++或--操作，必须使用内核提供的API。- Linux 7.0新增了内存顺序变体（
_relaxed、_acquire、_release），但大多数驱动用默认版本即可。 - 原子位操作直接对内存地址操作，常用于标志位管理。
test_and_set_bit是实现简单锁的原型。 - 原子操作的适用场景：保护单个整数或位。复杂场景需要用锁。