C++ 多线程进阶：深入理解互斥锁与竞态条件

公共资源 ticket 被五个线程争夺。理论上票数归零应停止，但运行结果可能显示为负数（如 -4）。这是因为多线程环境下的竞争。

以票数为 1 为例：线程 A 读取到 1，准备休息；线程 B 也读取到 1，准备休息。A 醒来减 1 变为 0；B 醒来再次减 1 变为 -1。

这就是经典的 check-then-act race（检查后执行竞态）。

汇编层面看：

; if (ticket > 0)
LOAD R1, [ticket] ; R1 = ticket
CMP R1, 0         ; 比较 R1 和 0
JLE END_IF        ; 如果 <= 0，跳走
; usleep(1000)
CALL usleep       ; 耗时操作
; ticket--
LOAD R2, [ticket] ; 重新读取内存
SUB R2, 1         ; R2 = R2 - 1
STORE [ticket], R2; 写回
END_IF:

关键点在于：判断时用的是 R1，真正减法时又重新 LOAD R2, [ticket] 读了一次内存。两次读取之间，其他线程可能修改了内存值。

解决方案：互斥锁

为了防止上述问题，我们引入锁的概念。

#include <iostream>
#include <thread>
#include <vector>
#include <string>
#include <cstdio>
#include <unistd.h>
#include <pthread.h>

int ticket = 100;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;

void routine(std::string name) {
    while (true) {
        pthread_mutex_lock(&lock);
        if (ticket > 0) {
            usleep(1000);
            ticket--;
            printf("%s sold ticket, now tickets number:%d\n", name.c_str(), ticket);
            pthread_mutex_unlock(&lock);
        } else {
            pthread_mutex_unlock(&lock);
            break;
        }
    }
    return;
}

int main() {
    std::vector<std::thread> threads;
    for (int i = 0; i < 5; i++) {
        std::string name = "thread-";
        name += std::to_string(i);
        threads.emplace_back(routine, name);
    }
    for (auto& thread : threads) {
        thread.join();
    }
    return 0;
}

现在运行正常，票数准确归零。这里的锁称为互斥锁 (Mutex)。

• 特点：同一时间只有一个线程能持有锁。
• 用法：pthread_mutex_lock() 加锁，pthread_mutex_unlock() 解锁。

临界区与上锁位置

我们需要保护的是访问共享资源的那部分代码，即临界区 (Critical Section)。

• 核心规则：同一时刻，只允许一个线程进入临界区。
• 保护方式：进入前加锁，离开后解锁。

解锁时机的重要性

如果在 else 分支直接 break 而未解锁，会导致死锁。因为线程持有了锁却退出了，其他线程永远无法获取锁。

死锁产生的四个必要条件（Coffman 条件）：

1. 互斥：资源独占。
2. 占有并等待：已持有资源等待其他资源。
3. 不可剥夺：只能由持有者释放。
4. 循环等待：形成等待链。

因此，每个分支路径都必须记得解锁。

锁的粒度

注意 usleep 不应放在锁内部。如果线程拿着锁睡觉，会阻塞其他所有需要该锁的线程，这是非常低效的。 优化后的逻辑应将耗时操作移出临界区：

pthread_mutex_lock(&lock);
if (ticket > 0) {
    ticket--;
    printf("%s sold ticket...\n", name.c_str());
}
pthread_mutex_unlock(&lock);
// 耗时操作移到外面
usleep(1000);

(注：为了保持原逻辑完整性，此处主要强调锁的范围控制)

公平性问题

即使加了锁，也可能出现某个线程一直抢到票的情况。这说明互斥锁只保证互斥，不保证公平。谁先抢到 CPU 调度，谁就有机会先拿到锁。

核心要点

多线程环境下，公共资源竞争极易引发数据异常。通过抢票示例，我们看到了 check-then-act race 如何导致负数票。引入互斥锁能有效隔离临界区，确保数据一致性。但开发者需注意锁的范围不宜过大（避免'抱着锁睡觉'），且必须保证所有退出路径都能正确解锁，以防死锁。最后记住，互斥锁维护的是秩序而非公平，合理设计同步策略才是关键。