C++锁机制与信号机制对比分析

#include <mutex>
std::mutex mtx;
void thread_func() {
    mtx.lock();
    // 访问共享资源
    mtx.unlock();
}

{
    std::lock_guard<std::mutex> lock(mtx);
    // 自动加锁，离开作用域自动解锁
}

std::unique_lock<std::mutex> lock(mtx, std::defer_lock);
lock.lock(); // 手动加锁
// ...
lock.unlock(); // 可提前解锁

#include <shared_mutex>
std::shared_mutex rw_mtx;
// 读操作（共享锁）
{
    std::shared_lock<std::shared_mutex> lock(rw_mtx);
    // 多个读线程可同时访问
}
// 写操作（独占锁）
{
    std::unique_lock<std::shared_mutex> lock(rw_mtx);
    // 仅一个写线程可访问
}

std::lock(mtx1, mtx2); // 原子性锁定多个互斥量
std::lock_guard<std::mutex> lock1(mtx1, std::adopt_lock);
std::lock_guard<std::mutex> lock2(mtx2, std::adopt_lock);

std::mutex mtx;
std::condition_variable cv;
bool data_ready = false;
// 等待线程
{
    std::unique_lock<std::mutex> lock(mtx);
    cv.wait(lock, [] { return data_ready; }); // 防止虚假唤醒
    // 条件满足后执行操作
}
// 通知线程
{
    std::lock_guard<std::mutex> lock(mtx);
    data_ready = true;
    cv.notify_one(); // 或 notify_all()
}

cv.wait(lock, predicate); // 等价于 while (!predicate) cv.wait(lock);

#include <semaphore>
std::counting_semaphore<10> sem(3); // 最大计数10，初始3
sem.acquire(); // 计数减1（如果计数为0则阻塞）
// 访问资源
sem.release(); // 计数加1