【C++】C++多线程编程锁（lock）的使用

C++ 中的锁详解与使用示例

在 C++ 多线程编程中，锁是同步机制的核心工具，用于防止数据竞争（Data Race）和保证线程安全。C++11 在 <mutex> 头文件中提供了多种锁类型，以下是详细解析：

1. std::mutex（基本互斥锁）

特性：

• 不可重入（同一线程重复加锁会导致死锁）
• 需手动管理锁的生命周期（lock()/unlock()）
• 提供 try_lock() 尝试非阻塞加锁

使用场景：简单临界区保护

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

std::mutex mtx;
int counter = 0;

void increment() {
    for (int i = 0; i < 100000; ++i) {
        mtx.lock();       // 手动加锁
        ++counter;        // 临界区操作
        mtx.unlock();     // 手动解锁
    }
}

int main() {
    std::thread t1(increment);
    std::thread t2(increment);
    t1.join(); t2.join();
    std::cout << "Counter: " << counter << "\n";  // 正确输出 200000
}

风险：若临界区抛出异常，可能导致死锁（推荐使用 RAII 锁）

2. std::lock_guard（RAII 作用域锁）

特性：

• 构造时自动加锁，析构时自动解锁
• 不可手动解锁或复制
• 零额外开销（推荐基础使用）

使用场景：简单临界区保护

void safe_increment() {
    for (int i = 0; i < 100000; ++i) {
        std::lock_guard<std::mutex> lock(mtx);  // 自动加锁
        ++counter;  // 离开作用域自动解锁（即使发生异常）
    }
}

3. std::unique_lock（灵活锁）

特性：

• 支持延迟加锁（defer_lock）、手动解锁、条件变量
• 可移动（不可复制）
• 比 lock_guard 略高开销

使用场景：需要灵活控制锁的场景

#include <condition_variable>

std::condition_variable cv;
bool data_ready = false;

// 生产者
void producer() {
    std::unique_lock<std::mutex> lock(mtx, std::defer_lock);  // 延迟加锁
    // ... 准备数据（非临界区）...
    lock.lock();              // 手动加锁
    data_ready = true;
    lock.unlock();            // 手动提前解锁
    cv.notify_one();          // 通知消费者
}

// 消费者
void consumer() {
    std::unique_lock<std::mutex> lock(mtx);
    cv.wait(lock, []{ return data_ready; });  // 条件变量等待
    // ... 处理数据 ...
}

4. std::recursive_mutex（递归锁）

特性：

• 允许同一线程多次加锁
• 解锁次数必须匹配加锁次数
• 比普通互斥锁性能稍差

使用场景：递归函数/可重入代码

std::recursive_mutex rec_mtx;

void recursive_func(int n) {
    std::lock_guard<std::recursive_mutex> lock(rec_mtx);
    if (n > 0) {
        std::cout << n << " ";
        recursive_func(n - 1);  // 递归调用（同一线程再次加锁）
    }
}

// 输出：5 4 3 2 1

5. std::timed_mutex（超时锁）

特性：

• 支持 try_lock_for() 和 try_lock_until()
• 避免无限期阻塞

使用场景：需要超时控制的场景

std::timed_mutex timed_mtx;

void timed_task() {
    auto timeout = std::chrono::milliseconds(100);
    if (timed_mtx.try_lock_for(timeout)) {
        std::cout << "Lock acquired\n";
        // ... 操作 ...
        timed_mtx.unlock();
    } else {
        std::cout << "Timeout!\n";
    }
}

6. 多锁管理（避免死锁）

技术：同时锁定多个互斥量（原子操作）

C++11 方案：std::lock() + std::adopt_lock

std::mutex mtx1, mtx2;

void safe_operation() {
    std::lock(mtx1, mtx2);  // 同时锁定（死锁安全）
    std::lock_guard<std::mutex> lock1(mtx1, std::adopt_lock);  // 接管已锁定互斥量
    std::lock_guard<std::mutex> lock2(mtx2, std::adopt_lock);
    // ... 操作共享资源 ...
}

C++17 方案：std::scoped_lock（推荐）

void safe_operation_cpp17() {
    std::scoped_lock lock(mtx1, mtx2);  // 自动管理多个锁
    // ... 操作共享资源 ...
}

7. std::shared_mutex（读写锁，C++17）

特性：

• 共享锁（读锁）：多个线程可同时获取
• 排他锁（写锁）：独占访问
• 适用于读多写少场景

#include <shared_mutex>

std::shared_mutex rw_mutex;
int shared_data = 0;

// 读线程（可并发）
void reader() {
    std::shared_lock lock(rw_mutex);  // 共享锁
    std::cout << "Read: " << shared_data << "\n";
}

// 写线程（独占）
void writer(int value) {
    std::unique_lock lock(rw_mutex);  // 排他锁
    shared_data = value;
}

锁使用的最佳实践

1. 优先使用 RAII 锁：lock_guard（简单场景）、unique_lock（灵活场景）
2. 最小化临界区：锁内只包含必要操作
3. 避免嵌套锁：如需多锁，使用 std::lock 或 std::scoped_lock
4. 慎用递归锁：优先重构代码避免递归加锁
5. 锁粒度选择：
   • 高频读：shared_mutex
   • 超时需求：timed_mutex
6. 配合条件变量：使用 unique_lock 实现线程间通信

死锁预防：固定加锁顺序、使用超时锁、RAII 模式、静态分析工具（如 Clang ThreadSanitizer）

完整示例：生产者-消费者模型

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <queue>

std::mutex mtx;
std::condition_variable cv;
std::queue<int> data_queue;
const int MAX_SIZE = 10;

void producer() {
    for (int i = 0; i < 100; ++i) {
        std::unique_lock<std::mutex> lock(mtx);
        cv.wait(lock, []{ return data_queue.size() < MAX_SIZE; });
        
        data_queue.push(i);
        std::cout << "Produced: " << i << "\n";
        
        lock.unlock();
        cv.notify_one();  // 通知消费者
    }
}

void consumer() {
    while (true) {
        std::unique_lock<std::mutex> lock(mtx);
        cv.wait(lock, []{ return !data_queue.empty(); });
        
        int data = data_queue.front();
        data_queue.pop();
        std::cout << "Consumed: " << data << "\n";
        
        if (data == 99) break;  // 终止条件
        lock.unlock();
        cv.notify_one();  // 通知生产者
    }
}

int main() {
    std::thread prod(producer);
    std::thread cons(consumer);
    prod.join(); cons.join();
}