C++中常用的同步工具：互斥锁（Mutex）、临界区（Critical Section）和信号量（Semaphore）

在多线程编程中，同步机制是保证数据安全和线程协作的核心。C++中常用的同步工具包括互斥锁（Mutex）、临界区（Critical Section） 和信号量（Semaphore），它们各自适用于不同场景，解决线程间资源竞争和协作问题。本文将详细解析这三种机制的原理、C++实现及适用场景。

一、互斥锁（Mutex）：独占式资源保护

1. 核心概念

互斥锁（Mutual Exclusion）是最基础的同步原语，其核心功能是保证同一时间只有一个线程能访问共享资源。它通过“加锁-访问-解锁”的流程，强制线程对资源的独占式访问，从而避免数据竞争。

互斥锁的核心逻辑：

• 线程访问共享资源前，必须先获取锁（lock）。
• 若锁已被其他线程持有，当前线程会阻塞等待，直到锁被释放。
• 线程完成访问后，必须释放锁（unlock），让其他线程有机会获取。

2. C++标准库实现

C++11 引入了 <mutex> 头文件，提供了多种互斥锁类型，满足不同场景需求：

类型	特点	适用场景
std::mutex	基础互斥锁，不可递归加锁（同一线程重复加锁会导致死锁）。	大多数单锁场景，无递归需求。
std::recursive_mutex	允许同一线程多次加锁（需保证解锁次数与加锁次数相同）。	递归函数访问共享资源的场景。
std::timed_mutex	支持超时加锁（try_lock_for/try_lock_until），避免永久阻塞。	需要设置锁等待超时的场景。
std::recursive_timed_mutex	结合递归锁和超时锁的特性。	递归访问且需超时控制的场景。
std::shared_mutex	C++17 引入，支持“共享锁”（多线程读）和“独占锁”（单线程写）。	读多写少的场景（如缓存、配置数据）。

3. 示例代码

#include <iostream>
#include <thread>
#include <mutex>

std::mutex mtx; // 基础互斥锁
int shared_value = 0;

// 安全地递增共享变量
void safe_increment(int times) {
    for (int i = 0; i < times; ++i) {
        // 使用 lock_guard 自动管理锁（RAII）
        std::lock_guard<std::mutex> lock(mtx); 
        shared_value++; // 临界区：受锁保护的共享资源访问
    }
}

int main() {
    std::thread t1(safe_increment, 100000);
    std::thread t2(safe_increment, 100000);
    
    t1.join();
    t2.join();
    
    std::cout << "共享变量最终值：" << shared_value << std::endl; // 预期 200000
    return 0;
}

关键说明：

• 推荐使用 std::lock_guard 或 std::unique_lock 管理锁的生命周期，避免因异常导致的锁泄漏（忘记解锁）。
• std::shared_mutex 需配合 std::shared_lock（读操作，共享锁）和 std::unique_lock（写操作，独占锁）使用，优化读多写少场景的性能。

二、临界区（Critical Section）：需要保护的代码段

1. 核心概念

临界区并非具体的同步工具，而是访问共享资源的代码段——这段代码在多线程环境下必须被独占式执行，否则会导致数据竞争。简单说：临界区是“需要保护的代码”，而互斥锁是“保护代码的工具”。

临界区的核心原则：

• 同一时间只能有一个线程进入临界区。
• 线程在临界区内的操作必须是原子的（不可分割），确保其他线程看到的是完整结果。

2. 与互斥锁的关系

临界区的保护需要依赖同步工具（如互斥锁）实现。例如，用互斥锁包裹临界区代码，即可保证其独占式执行：

// 临界区：访问共享资源的代码段
{
    std::lock_guard<std::mutex> lock(mtx); // 加锁保护
    shared_value++; // 共享资源操作
} // 自动解锁，退出临界区

3. 平台特定的“临界区”实现

在 Windows 系统中，有一个名为 CRITICAL_SECTION 的同步对象（常被称为“临界区”），功能类似 std::mutex，但仅能在同一进程内的线程间同步（不支持跨进程），性能略高于互斥锁。

Windows 临界区示例：

#include <windows.h>

CRITICAL_SECTION cs; // Windows 临界区对象
int shared_value = 0;

void win_safe_increment(int times) {
    for (int i = 0; i < times; ++i) {
        EnterCriticalSection(&cs); // 进入临界区（加锁）
        shared_value++;
        LeaveCriticalSection(&cs); // 离开临界区（解锁）
    }
}

int main() {
    InitializeCriticalSection(&cs); // 初始化临界区
    
    HANDLE t1 = CreateThread(nullptr, 0, (LPTHREAD_START_ROUTINE)win_safe_increment, (void*)100000, 0, nullptr);
    HANDLE t2 = CreateThread(nullptr, 0, (LPTHREAD_START_ROUTINE)win_safe_increment, (void*)100000, 0, nullptr);
    
    WaitForSingleObject(t1, INFINITE);
    WaitForSingleObject(t2, INFINITE);
    CloseHandle(t1);
    CloseHandle(t2);
    
    DeleteCriticalSection(&cs); // 销毁临界区
    printf("共享变量最终值：%d\n", shared_value);
    return 0;
}

C++标准与平台差异：

• C++ 标准库中没有“临界区”对象，临界区仅作为“需要保护的代码段”概念存在。
• Windows 的 CRITICAL_SECTION 是平台特定实现，与 std::mutex 相比，优势是进程内同步效率高，劣势是不支持跨进程。

三、信号量（Semaphore）：控制并发访问数量

1. 核心概念

信号量是一种更灵活的同步机制，它通过一个计数器控制同时访问资源的线程数量。与互斥锁（仅允许1个线程访问）不同，信号量可允许N个线程同时访问，适用于限制资源的并发访问量（如连接池、线程池）。

信号量的核心操作：

• P操作（Wait）：计数器减1。若计数器 >= 0，线程可继续执行；若计数器 < 0，线程阻塞等待。
• V操作（Post）：计数器加1。若有线程阻塞，唤醒其中一个继续执行。

2. C++标准库实现

C++20 引入了 <semaphore> 头文件，提供两种信号量类型：

类型	特点	适用场景
std::counting_semaphore<N>	计数信号量，最大计数为 N（模板参数）。	限制 N 个线程同时访问资源（如连接池限制10个连接）。
std::binary_semaphore	二进制信号量（计数只能是 0 或 1），等价于 std::counting_semaphore<1>。	类似互斥锁，但可由其他线程释放（互斥锁需持有者释放）。

信号量的核心接口：

• acquire()：执行 P 操作（计数器减1，若为负则阻塞）。
• try_acquire()：尝试 P 操作（成功返回 true，失败立即返回 false，不阻塞）。
• release(count = 1)：执行 V 操作（计数器加 count，唤醒等待线程）。

3. 示例代码：限制并发访问

#include <iostream>
#include <thread>
#include <semaphore>
#include <vector>

// 限制最多 3 个线程同时访问资源
std::counting_semaphore<3> sem(3); // 初始计数为 3
int resource_usage = 0; // 记录当前资源使用量

void access_resource(int id) {
    sem.acquire(); // P操作：获取访问权限（计数-1）
    
    // 临界区：访问共享资源
    resource_usage++;
    std::cout << "线程 " << id << " 访问资源，当前使用量：" << resource_usage << std::endl;
    std::this_thread::sleep_for(std::chrono::milliseconds(100)); // 模拟资源访问
    resource_usage--;
    
    sem.release(); // V操作：释放访问权限（计数+1）
}

int main() {
    std::vector<std::thread> threads;
    // 创建 10 个线程尝试访问资源
    for (int i = 0; i < 10; ++i) {
        threads.emplace_back(access_resource, i);
    }
    
    for (auto& t : threads) {
        t.join();
    }
    return 0;
}

输出说明：
程序运行时，始终只有最多 3 个线程同时访问资源（resource_usage 最大为 3），体现了信号量的并发限制能力。

4. 信号量 vs 互斥锁

特性	互斥锁（std::mutex）	信号量（std::counting_semaphore）
访问限制	仅允许 1 个线程访问	允许 N 个线程同时访问（N 可配置）
所有权	锁的持有者必须释放锁（线程关联）	可由任意线程释放（无所有权关联）
典型用途	保护独占资源（如全局变量）	限制并发数量（如连接池、线程池）
特殊场景支持	递归锁支持同一线程重复加锁	二进制信号量可模拟互斥锁，但更灵活

四、三者对比与适用场景总结

机制	本质	核心功能	适用场景	平台兼容性
互斥锁	同步工具	保证资源独占访问（1线程）	保护共享变量、数据结构等独占资源	C++标准（跨平台）
临界区	代码段（概念）	需独占执行的代码段（需其他工具保护）	所有访问共享资源的代码逻辑	通用概念（无平台限制）
信号量	同步工具	控制资源并发访问数量（N线程）	限制连接数、线程池大小、生产者-消费者模型	C++20标准（跨平台）

选择建议：

1. 若需保护共享资源不被同时修改（如全局变量、链表），优先使用 互斥锁（std::mutex 或 std::shared_mutex）。
2. 若需限制同时访问资源的线程数量（如数据库连接池、限流），使用 信号量（std::counting_semaphore）。
3. 临界区是“需要保护的代码段”，而非工具——任何访问共享资源的代码都应视为临界区，并通过互斥锁或信号量保护。

结语

互斥锁、临界区和信号量是多线程同步的核心机制，它们从不同层面解决资源竞争问题：互斥锁保证独占访问，信号量控制并发数量，临界区则是需要保护的代码逻辑本身。在C++开发中，应优先使用标准库提供的跨平台工具（如 std::mutex、std::counting_semaphore），并通过RAII（如 std::lock_guard）管理资源，在保证线程安全的同时，兼顾代码的可维护性和性能。