Linux 线程互斥原理与实战：从 mutex 到 RAII 封装

编译运行：gcc ticket.c -o ticket -lpthread ./ticket

你会发现余票出现 0、-1、-2 等异常结果。明明判断了 ticket > 0，为何会卖负数？

问题根源剖析

1. 线程调度的随机性：线程 1 判断 ticket=1 为真后，可能被切换出去；此时线程 2、3、4 也判断为真，都进入逻辑，导致多次减 1。
2. 耗时操作放大竞争：usleep(1000) 模拟业务耗时，增加了被调度的概率。即使去掉它，由于调度随机性，问题依然存在。
3. ticket-- 非原子操作：这是最根本的原因。底层对应三条汇编指令：Load（加载到寄存器）、Update（减 1）、Store（写回内存）。这三步之间可被中断，导致状态混乱。

要解决这个问题，需要让临界区满足三个要求：互斥行为、唯一准入、非阻塞无关。本质上需要一把锁，在 Linux 下即互斥量（mutex）。

Linux 下的互斥量：mutex 使用解析

Linux POSIX 线程库提供了 pthread_mutex_t 作为核心工具。它像一把钥匙，只有拿到锁的线程才能进入临界区。

核心接口

初始化

互斥量初始化分两种场景：

• 静态分配（全局/静态变量）：

  pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
  

• 动态分配（局部/堆上）：

  int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);
  

  参数 attr 通常设为 NULL 使用默认属性。

销毁

使用 pthread_mutex_destroy 释放资源。注意：静态分配的互斥量不需要手动销毁；不要销毁已加锁的互斥量。

加锁与解锁

• 加锁 (pthread_mutex_lock)：获取锁，若已被锁定则阻塞等待。
• 解锁 (pthread_mutex_unlock)：释放锁，唤醒等待线程。

注意：加锁解锁必须成对出现，且必须在同一线程中调用。临界区代码应尽可能精简。

实战改造：加锁的售票系统

我们用互斥量包裹临界区，保证同一时刻只有一个线程操作 ticket。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>

int ticket = 100;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

void *route(void *arg) {
    char *id = (char*)arg;
    while (1) {
        pthread_mutex_lock(&mutex);
        if (ticket > 0) {
            usleep(1000);
            printf("%s sells ticket:%d\n", id, ticket);
            ticket--;
        } else {
            pthread_mutex_unlock(&mutex);
            break;
        }
        pthread_mutex_unlock(&mutex);
    }
    return NULL;
}

int main() {
    pthread_t t1, t2, t3, t4;
    pthread_create(&t1, NULL, route, "thread 1");
    pthread_create(&t2, NULL, route, "thread 2");
    pthread_create(&t3, NULL, route, "thread 3");
    pthread_create(&t4, NULL, route, "thread 4");
    
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    pthread_join(t3, NULL);
    pthread_join(t4, NULL);
    
    pthread_mutex_destroy(&mutex);
    return 0;
}

关键点：

1. 定义全局互斥量并静态初始化。
2. 进入临界区前加锁，结束后立即解锁。
3. else 分支必须解锁：若 ticket <= 0 直接 break 而不解锁，会导致死锁。

运行结果将符合预期，余票从 100 递减至 1，无负数。

实现原理：硬件原子指令

互斥量本身如何保证原子性？依赖硬件提供的原子交换指令（如 x86 的 xchgb、ARM 的 swp）。这些指令不可分割，确保多处理器环境下总线访问的串行性。

伪代码模拟 lock 操作（假设初始值为 1 表示未锁定）：

lock:
    movb $0, %al          ; 准备锁定状态
    xchgb %al, mutex      ; 原子交换
    if (%al == 0) {
        挂起当前线程       ; 说明已被锁定
        goto lock         ; 重试
    }
    return 0              ; 加锁成功

解锁则是将值设为 1 并唤醒等待线程。简单来说：硬件原子指令保证了锁的安全性，锁保证了临界区的安全性。

C++ 封装：RAII 风格更安全

C 语言需手动管理锁，容易忘记解锁。C++ 利用 RAII（资源获取即初始化） 思想，将锁绑定对象生命周期，自动加锁解锁。

封装 Lock.hpp

#pragma once
#include <iostream>
#include <pthread.h>
#include <cassert>

namespace LockModule {
class Mutex {
public:
    Mutex(const Mutex &) = delete;
    const Mutex &operator=(const Mutex &) = delete;

    Mutex() {
        int ret = pthread_mutex_init(&_mutex, nullptr);
        assert(ret == 0);
    }

    void Lock() {
        int ret = pthread_mutex_lock(&_mutex);
        assert(ret == 0);
    }

    void Unlock() {
        int ret = pthread_mutex_unlock(&_mutex);
        assert(ret == 0);
    }

    ~Mutex() {
        pthread_mutex_destroy(&_mutex);
    }

private:
    pthread_mutex_t _mutex;
};

class LockGuard {
public:
    explicit LockGuard(Mutex &mutex) : _mutex(mutex) {
        _mutex.Lock();
    }

    ~LockGuard() {
        _mutex.Unlock();
    }

    LockGuard(const LockGuard &) = delete;
    const LockGuard &operator=(const LockGuard &) = delete;

private:
    Mutex &_mutex;
};
}

实战改造

#include <stdio.h>
#include <pthread.h>
#include "Lock.hpp"

using namespace LockModule;

int ticket = 1000;
Mutex mutex;

void *route(void *arg) {
    char *id = (char*)arg;
    while (1) {
        LockGuard guard(mutex); // 构造时自动加锁
        if (ticket > 0) {
            usleep(1000);
            printf("%s sells ticket:%d\n", id, ticket);
            ticket--;
        } else {
            break;
        }
        // 析构时自动解锁
    }
    return nullptr;
}

int main() {
    pthread_t t1, t2, t3, t4;
    pthread_create(&t1, NULL, route, "thread 1");
    pthread_create(&t2, NULL, route, "thread 2");
    pthread_create(&t3, NULL, route, "thread 3");
    pthread_create(&t4, NULL, route, "thread 4");
    
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    pthread_join(t3, NULL);
    pthread_join(t4, NULL);
    return 0;
}

优势：

1. 无需手动调用 unlock，即使 break 或异常也能保证解锁。
2. 代码更简洁，逻辑清晰。
3. 彻底避免'忘记解锁'导致的死锁。

实际开发中可直接使用 C++11 标准库的 std::mutex 和 std::lock_guard。

常见问题与避坑指南

死锁

多个线程互相持有对方需要的锁且不释放，形成循环等待。避免方法包括统一加锁顺序、一次性获取所有锁、设置超时时间等。

过度加锁

将非临界区代码（如 IO、打印）包裹在锁内会降低并发效率。优化技巧：

1. 临界区最小化：只锁核心逻辑。
2. 细粒度加锁：拆分大资源为小资源（如哈希表桶级锁）。
3. 自旋锁：短临界区可用 pthread_spinlock_t 避免上下文切换开销。

锁的拷贝

互斥量是独占资源，禁止拷贝赋值。C++ 中用 = delete 禁用，C 语言中避免值传递。

信号处理函数

信号处理函数中不能使用 pthread 互斥量，因为异步执行可能导致死锁。建议仅设置标志位或使用原子变量。

应用场景

只要多个线程同时访问并修改同一个共享资源，就需要互斥。典型场景包括：

• 售票/库存系统
• 银行转账
• 日志写入
• 缓存读写
• 生产消费模型

对于只读共享资源，无需互斥保护。

总结

线程互斥是多线程同步的基础。实际开发中还需结合线程同步（如条件变量）来协调执行顺序。掌握互斥量的原理、API 及现代封装方式，能写出安全高效的多线程代码。