C++ 锁管理：std::lock_guard 和 std::unique_lock 使用方法

1、std::lock_guard

概述:

• std::lock_guard 是一种简单的锁管理工具，用于自动化地加锁和解锁互斥量。
• 适用于需要简单、明确的锁定和解锁场景。

特点:

• 自动加锁：在构造时自动锁定互斥量。
• 自动解锁：在析构时自动释放锁。
• 不可手动解锁：不支持手动解锁或重新加锁。
• 性能开销小：由于功能简单，性能开销较小。

适用场景:

• 当锁定范围非常明确且简单，如在函数的起始和结束处保护一个共享资源。
• 当不需要在同一作用域内进行手动解锁或重新加锁操作时。

示例代码:

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

std::mutex mtx;
int counter = 0;

void increment() {
    std::lock_guard<std::mutex> lock(mtx); // 自动加锁
    ++counter;
    std::cout << "Counter: " << counter << std::endl;
    // 自动解锁在 lock 离开作用域时
}

int main() {
    std::thread t1(increment);
    std::thread t2(increment);

    t1.join();
    t2.join();

    return 0;
}

2、std::unique_lock

概述:

• std::unique_lock 提供了比 std::lock_guard 更多的功能和灵活性。
• 适用于需要更复杂控制的锁定和解锁场景，如与条件变量配合使用。

特点:

• 手动解锁：支持手动调用 unlock() 方法释放锁。
• 重新加锁：支持在手动解锁后重新调用 lock() 方法加锁。
• 延迟锁定：可以在构造时选择不立即锁定（使用 std::defer_lock 参数）。
• 与条件变量配合使用：可以与 std::condition_variable 一起使用来实现等待和通知机制。
• 性能开销：由于提供了更多功能，相比 std::lock_guard 性能开销略大。

适用场景:

• 当需要在同一作用域内手动释放锁，或者需要在不同的作用域中重新加锁时。
• 当需要与 std::condition_variable 一起使用以实现线程的等待和通知机制时。
• 当锁定范围不够明确，需要更灵活的锁控制时。

示例代码:

手动解锁和重新加锁:

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

std::mutex mtx;
int counter = 0;

void increment() {
    std::unique_lock<std::mutex> lock(mtx);
    ++counter;
    std::cout << "Counter: " << counter << std::endl;
    
    lock.unlock(); // 手动解锁

    // 在这里进行不需要锁的操作
    std::this_thread::sleep_for(std::chrono::seconds(1));
    
    lock.lock(); // 重新加锁
    ++counter;
    std::cout << "Counter after re-lock: " << counter << std::endl;
}

int main() {
    std::thread t1(increment);
    std::thread t2(increment);

    t1.join();
    t2.join();

    return 0;
}

与条件变量配合使用:

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

std::mutex mtx;
std::condition_variable cv;
bool ready = false;

void waiting_thread() {
    std::unique_lock<std::mutex> lock(mtx);
    cv.wait(lock, [] { return ready; }); // 与条件变量配合使用
    std::cout << "Condition met!" << std::endl;
}

void signaling_thread() {
    {
        std::unique_lock<std::mutex> lock(mtx);
        ready = true;
    } // 手动解锁在这里完成
    cv.notify_one(); // 通知等待的线程
}

int main() {
    std::thread w_thread(waiting_thread);
    std::thread s_thread(signaling_thread);

    w_thread.join();
    s_thread.join();

    return 0;
}

3、总结

• std::lock_guard：适用于简单的自动化锁定和解锁场景，功能有限但性能开销小。
• std::unique_lock：适用于需要更复杂控制的场景，例如手动解锁、重新加锁及与条件变量配合使用，提供了更多的灵活性，但性能开销较大。