从银行账户到数组求和：用5个生活化例子彻底搞懂操作系统中的‘竞态条件’

从银行账户到数组求和：用5个生活化例子彻底搞懂操作系统中的"竞态条件"

竞态条件就像厨房里两个厨师同时抢最后一把刀——谁先拿到谁就能继续做菜，另一个只能干等着。这种混乱场景在操作系统中每天都在上演，只不过主角变成了线程和进程。想象一下，当多个执行流同时操作共享资源时，如果没有合适的同步机制，系统就会陷入不可预测的状态。本文将通过五个程序员熟悉的日常场景，带你看透竞态条件的本质。

1. 银行转账：并发世界的第一个陷阱

假设你和伴侣共享一个银行账户，余额显示为250美元。某个时刻，你正在用手机APP发起50美元取款操作，同时伴侣在ATM存入100美元。理想情况下，最终余额应该是300美元（250-50+100），但并发操作可能导致意外结果。

典型的转账操作伪代码如下：

void withdraw(int amount) { int balance = get_balance(); // 读取当前余额 balance -= amount; // 本地计算新余额 set_balance(balance); // 写回新余额 }

竞态条件发生过程：

1. 线程A（取款）读取余额250美元
2. 线程B（存款）读取余额250美元
3. 线程A计算新余额200美元但尚未写入
4. 线程B计算新余额350美元并写入
5. 线程A写入200美元
6. 最终余额错误地变为200美元

解决方案对比表：

提示：在金融系统中，除了基本的同步机制，还需要考虑事务的ACID特性，简单的互斥锁可能不足以满足所有需求。

2. 数组堆栈：当push遇上pop

数组实现的堆栈是最基础的数据结构之一，但在并发环境下，简单的push()和pop()操作可能引发灾难。考虑以下典型实现：

#define MAX 100 int stack[MAX]; int top = -1; void push(int item) { stack[++top] = item; // 竞态点1：top自增与写入非原子 } int pop() { return stack[top--]; // 竞态点2：读取与top修改非原子 }

竞态场景分析：

1. 线程A执行push(x)，读取top值为0
2. 线程B同时执行pop()，读取top值也为0
3. 线程B将top减为-1并返回stack[0]
4. 线程A将top加为1，写入stack[1]=x
5. 结果：x被写入错误位置，且stack[0]被错误弹出

可视化时序问题：

时间线 | 线程A (push) | 线程B (pop) ------------------------------------------------------- t1 | 读取top=0 | t2 | | 读取top=0 t3 | | 设置top=-1 t4 | 设置top=1 | t5 | 写入stack[1]=x |

修复方案：

pthread_mutex_t stack_lock = PTHREAD_MUTEX_INITIALIZER; void safe_push(int item) { pthread_mutex_lock(&stack_lock); stack[++top] = item; pthread_mutex_unlock(&stack_lock); } int safe_pop() { pthread_mutex_lock(&stack_lock); int item = stack[top--]; pthread_mutex_unlock(&stack_lock); return item; }

3. 多核数组求和：并行计算的陷阱

现代系统常利用多核并行计算，比如对大型数组求和。看似简单的求和操作，在并行环境下也可能出现竞态：

原始并行求和算法：

for j in 1 to log2(N): for k in 1 to N: if (k+1) % 2^j == 0: values[k] += values[k - 2^(j-1)] # 竞态点

问题本质：当多个核同时执行values[k] += ...时，读取和写入操作可能交错：

1. 核A读取values[k]初始值100
2. 核B读取values[k]初始值100
3. 核A计算新值100+50=150
4. 核B计算新值100+30=130
5. 核A写入150
6. 核B写入130（覆盖150）

解决方案对比：

• 内存屏障：确保指令执行顺序

  __atomic_fetch_add(&values[k], values[k - stride], __ATOMIC_ACQ_REL);

• 规约算法：每个核计算局部和，最后汇总

  # 每个核处理独立数据块 local_sum = sum(values[my_start:my_end]) # 然后安全地合并结果 atomic_add(global_sum, local_sum)

4. 自旋锁的智慧：忙等待的艺术

自旋锁是多核系统中的重要同步原语，但其实现暗藏玄机。对比两种实现方式：

朴素版自旋锁：

void lock(int *lock) { while (compare_and_swap(lock, 0, 1) != 0) ; // 忙等待 }

优化版CCAS（Compare-Compare-And-Swap）：

void lock(int *lock) { while (1) { if (*lock == 0) { // 第一次检查 if (!compare_and_swap(lock, 0, 1)) break; } } }

性能对比测试数据：

注意：在单核系统上，自旋锁会浪费整个时间片，应改用会休眠的互斥锁。

5. 计数器之争：原子操作的威力

Web服务器需要统计访问量，简单的hits++在并发下可能丢失更新：

危险实现：

int hits; void increment_hits() { hits++; // 实际需要3条机器指令 }

安全方案对比：

1. 互斥锁方案：

   pthread_mutex_t hit_lock = PTHREAD_MUTEX_INITIALIZER; void safe_increment() { pthread_mutex_lock(&hit_lock); hits++; pthread_mutex_unlock(&hit_lock); }

2. 原子操作方案：

   #include <stdatomic.h> atomic_int hits; void faster_increment() { atomic_fetch_add(&hits, 1); }

性能测试结果（百万次调用）：

在实际项目中，Linux内核的percpu_counter是个很好的参考——它为每个CPU维护局部计数器，定期汇总，兼具性能和正确性。