基本原理说明
在 x86 和 ARM 架构上，原子操作通常利用硬件提供的原子指令来实现，比如 LOCK 前缀（x86）或 LDREX/STREX（ARM）。以下是一些关键的原子操作（例如原子递增和比较交换）的汇编实现。
1. x86 架构的原子操作
（1）原子递增
x86 的 LOCK 前缀可以用来保证指令在多核处理器上的原子性。例如原子递增操作：
实现原子递增
global atomic_increment
section .text
atomic_increment:mov eax, 1 ; 设置递增值为 1lock xadd [rdi], eax ; 对地址 rdi 所指向的变量执行原子加操作add rax, 1 ; xadd 返回的是原值，rax = 原值 + 1ret
解释：
LOCK XADD [rdi], eax：对rdi指向的地址执行原子加操作，将原值存入eax，并把eax加上后写回rdi。- 使用
LOCK前缀可以保证多核环境下的原子性。
（2）比较并交换（CAS）
x86 提供了 CMPXCHG 指令，可以用来实现原子的比较并交换（CAS）。
实现原子 CAS
global atomic_compare_exchange
section .text
atomic_compare_exchange:mov rax, rsi ; 将期望值放入 raxlock cmpxchg [rdi], rdx ; 如果 [rdi] 的值等于 rax（期望值），将 rdx 写入 [rdi]ret
参数说明：
rdi：目标地址。rsi：期望值。rdx：需要交换的值。
解释：
LOCK CMPXCHG [rdi], rdx：- 如果
[rdi]的值等于RAX，则将rdx写入[rdi]。 - 否则将
[rdi]的当前值写入RAX。
- 如果
- 返回值：
RAX中存储的是rdi的旧值，调用者可以根据是否等于rsi判断交换是否成功。
2. ARM 架构的原子操作
ARM 使用 LDREX/STREX 指令对原子操作进行支持。这是一种 负载-存储排他模型，可以保证在加载到存储之间没有其他线程或进程修改目标变量。
（1）原子递增
在 ARM 架构下，使用 LDREX/STREX 实现原子递增：
实现原子递增
.global atomic_increment
atomic_increment:mov r1, #1 ; 将 1 存入 r1（递增值）
1:ldrex r0, [r0] ; 使用 LDREX 加载 [r0] 的值到 r0add r0, r0, r1 ; r0 = r0 + 1strex r2, r0, [r0] ; 尝试将 r0 写回 [r0]，如果成功 r2 = 0cmp r2, #0 ; 检查写入是否成功bne 1b ; 如果不成功，重试dmb ; 数据内存屏障，确保操作完成bx lr
解释：
LDREX：加载目标地址的值，同时标记为“独占”访问。STREX：尝试存储值到目标地址，如果目标地址在此期间被其他核修改，存储操作会失败，返回非 0。- 使用循环保证操作成功。
（2）比较并交换（CAS）
实现原子 CAS
.global atomic_compare_exchange
atomic_compare_exchange:ldrex r0, [r1] ; 从地址 r1 加载值到 r0（旧值）cmp r0, r2 ; 比较 r0 和 r2（期望值）bne 1f ; 如果不相等，跳转到 1f，返回旧值strex r3, r3, [r1] ; 尝试将 r3 写入 [r1]，如果成功 r3 = 0cmp r3, #0 ; 检查是否存储成功bne atomic_compare_exchange ; 如果失败，重新尝试
1:dmb ; 数据内存屏障，保证一致性bx lr
参数说明：
r1：目标地址。r2：期望值。r3：要交换的值。
解释：
- 如果
LDREX加载的值与期望值（r2）相等，则尝试存储r3。 - 如果存储失败，则重复尝试。
- 成功后返回原值。
3. 汇编操作的注意事项
- x86 的强内存模型：
- x86 硬件有一个相对强的内存序，很多情况下
LOCK前缀可以满足原子操作需求。
- x86 硬件有一个相对强的内存序，很多情况下
- ARM 的弱内存模型：
- ARM 是弱内存模型，使用
LDREX/STREX操作时，通常需要内存屏障（如DMB）来确保指令顺序和数据同步。
- ARM 是弱内存模型，使用
- 重试机制：
- 对于 ARM 的
LDREX/STREX模式，如果存储失败需要通过循环重试。
- 对于 ARM 的
- 指令可用性：
- 需要确保目标平台支持这些指令。比如
CMPXCHG在早期的 x86 处理器（如 80386）上不可用。
- 需要确保目标平台支持这些指令。比如
4. 比较总结
| 操作 | x86 | ARM |
|---|---|---|
| 原子递增 | LOCK XADD | LDREX + ADD + STREX |
| 原子比较交换 | LOCK CMPXCHG | LDREX + CMP + STREX |
| 内存屏障 | MFENCE（可选） | DMB |
x86 汇编通常较为简单，因为其强内存序模型降低了编程复杂性；ARM 则需要更明确的同步和屏障操作。
代码实现
my_atomic.h
#include <stdint.h>
#include <stdio.h>// 平台区分
#if defined(__x86_64__)#define ATOMIC_X86
#elif defined(__aarch64__)#define ATOMIC_ARM
#else#error "Unsupported platform"
#endif// ===================== x86 实现 =====================
#ifdef ATOMIC_X86// 原子递增
static inline int atomic_increment(int *addr) {int result;__asm__ __volatile__("lock xaddl %0, %1": "=r"(result), "+m"(*addr): "0"(1): "memory");return result + 1; // 返回递增后的值
}// 原子递减
static inline int atomic_decrement(int *addr) {int result;__asm__ __volatile__("lock xaddl %0, %1": "=r"(result), "+m"(*addr): "0"(-1) // 减 1: "memory");return result - 1; // 返回递减后的值
}// 原子比较交换
static inline int atomic_compare_exchange(int *addr, int expected, int desired) {int old;__asm__ __volatile__("lock cmpxchgl %2, %1": "=a"(old), "+m"(*addr): "r"(desired), "0"(expected): "memory");return old; // 返回旧值
}// 原子读取
static inline int atomic_load(int *addr) {int value;__asm__ __volatile__("movl %1, %0": "=r"(value): "m"(*addr): "memory");return value; // 返回读取值
}#endif // ATOMIC_X86// ===================== ARM 实现 =====================
#ifdef ATOMIC_ARM// 原子递增
static inline int atomic_increment(int *addr) {int old, tmp;do {__asm__ __volatile__("ldrex %0, [%2] \n" // 读取旧值到 old"add %1, %0, #1 \n" // tmp = old + 1"strex %0, %1, [%2] \n" // 尝试写回: "=&r"(old), "=&r"(tmp): "r"(addr): "memory", "cc");} while (old != 0); // 如果写失败，重试return tmp; // 返回递增后的值
}// 原子递减
static inline int atomic_decrement(int *addr) {int old, tmp;do {__asm__ __volatile__("ldrex %0, [%2] \n" // 读取旧值到 old"sub %1, %0, #1 \n" // tmp = old - 1"strex %0, %1, [%2] \n" // 尝试写回: "=&r"(old), "=&r"(tmp): "r"(addr): "memory", "cc");} while (old != 0); // 如果写失败，重试return tmp; // 返回递减后的值
}// 原子比较交换
static inline int atomic_compare_exchange(int *addr, int expected, int desired) {int old, status;do {__asm__ __volatile__("ldrex %0, [%2] \n" // 加载到 old"cmp %0, %3 \n" // 比较 old 和 expected"bne 1f \n" // 如果不相等，跳转到 1"strex %1, %4, [%2] \n" // 尝试写回 desired"1:": "=&r"(old), "=&r"(status): "r"(addr), "r"(expected), "r"(desired): "memory", "cc");} while (status != 0); // 如果写失败，重试return old; // 返回旧值
}// 原子读取
static inline int atomic_load(int *addr) {int value;__asm__ __volatile__("ldrex %0, [%1] \n" // 加载值到 value: "=&r"(value): "r"(addr): "memory");return value; // 返回读取值
}#endif // ATOMIC_ARM
my_atomic_test.c
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include "my_atomic.h"#define NUM_THREADS 4
#define ITERATIONS 1000volatile int shared_counter = 0; // 全局共享计数器// 线程函数：执行递增操作
void* thread_increment(void* arg) {for (int i = 0; i < ITERATIONS; i++) {atomic_increment((int*)&shared_counter);}return NULL;
}// 线程函数：执行递减操作
void* thread_decrement(void* arg) {for (int i = 0; i < ITERATIONS; i++) {atomic_decrement((int*)&shared_counter);}return NULL;
}int main() {pthread_t threads[NUM_THREADS];// 创建增量线程for (int i = 0; i < NUM_THREADS / 2; i++) {if (pthread_create(&threads[i], NULL, thread_increment, NULL) != 0) {perror("pthread_create");exit(EXIT_FAILURE);}}// 创建减量线程for (int i = NUM_THREADS / 2; i < NUM_THREADS; i++) {if (pthread_create(&threads[i], NULL, thread_decrement, NULL) != 0) {perror("pthread_create");exit(EXIT_FAILURE);}}// 等待所有线程完成for (int i = 0; i < NUM_THREADS; i++) {pthread_join(threads[i], NULL);}// 最终结果int final_value = atomic_load((int*)&shared_counter);printf("最终计数器值: %d\n", final_value);return 0;
}
ubuntu x86编译运行
$ gcc -pthread -o a.out my_atomic_test.c
$ ./a.out
最终计数器值: 0gitlab.0voice.com
