C++之std::lock_guard和std::unique_lock

std::lock_guard 和 std::unique_lock 都是 C++ 标准库提供的 RAII（Resource Acquisition Is Initialization）风格的锁机制，用于在作用域内管理互斥量 (std::mutex) 的锁定和解锁操作。它们帮助开发者更安全地处理多线程中的互斥量，避免手动锁定和解锁带来的潜在错误。

std::lock_guard

std::lock_guard 是一种简单的、不可重入的互斥量封装器。它在构造时锁定互斥量，在析构时自动解锁，非常适合用于存在明确作用域的临界区。

主要特点：

• 简单：只支持在构造时锁定，在析构时解锁，不支持手动解锁或重新锁定。
• 高效：因为其设计简单，没有额外的开销。

用法示例：

cpp

#include <iostream>
#include <thread>
#include <mutex>
 
std::mutex mtx;
 
void print_message(const std::string& message) {
    // 创建lock_guard对象，自动锁定互斥量
    std::lock_guard<std::mutex> lock(mtx);
    std::cout << message << std::endl;
    // 在lock_guard对象析构时，自动解锁互斥量
}
 
int main() {
    std::thread t1(print_message, "Hello from thread 1");
    std::thread t2(print_message, "Hello from thread 2");
 
    t1.join();
    t2.join();
 
    return 0;
}

std::unique_lock

std::unique_lock 提供了比 std::lock_guard 更灵活的锁管理功能。它允许手动锁定和解锁，并且可以延迟锁定或尝试锁定。

主要特点：

• 灵活性：可以手动解锁和重新锁定，可以延迟锁定，还可以尝试锁定。
• 更多功能：支持条件变量的等待操作，需要传递 std::unique_lock。

用法示例：

cpp

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
 
std::mutex mtx;
std::condition_variable cv;
bool ready = false;
 
void worker() {
    std::this_thread::sleep_for(std::chrono::seconds(1));
    
    {
        std::lock_guard<std::mutex> lock(mtx);
        ready = true;
    }
    
    cv.notify_one();
}
 
int main() {
    std::thread t(worker);
 
    {
        std::unique_lock<std::mutex> lock(mtx);
        cv.wait(lock, [] { return ready; });
    }
 
    std::cout << "Worker thread is done!" << std::endl;
 
    t.join();
 
    return 0;
}

在这个例子中，std::unique_lock 被用来等待条件变量。因为 cv.wait 需要传入一个 std::unique_lock 对象，所以我们必须使用 std::unique_lock 而不是 std::lock_guard。

比较：

• std::lock_guard：用于简单的、作用域明确的互斥量锁定。它没有解锁或重新锁定的功能。
• std::unique_lock：用于需要更复杂锁定行为的场景，如条件变量等待、手动解锁和重新锁定等。

选择哪一个取决于你的需求。如果你只需要简单的锁定机制，std::lock_guard 是首选，因为它更简单和高效。如果你需要更细粒度的控制和灵活性，那么 std::unique_lock 更为适用。

std::unique_lock 提供了手动解锁和重新锁定互斥量的功能，这使得它比 std::lock_guard 更加灵活。你可以使用 unlock() 来手动解锁互斥量，使用 lock() 来重新锁定互斥量。

下面是一个演示如何手动解锁和重新锁定互斥量的例子：

cpp

#include <iostream>
#include <thread>
#include <mutex>
 
std::mutex mtx;
 
void worker() {
    std::unique_lock<std::mutex> lock(mtx);
    std::cout << "Worker thread has locked the mutex." << std::endl;
 
    // 手动解锁互斥量
    lock.unlock();
    std::cout << "Worker thread has unlocked the mutex." << std::endl;
 
    // 模拟某些工作在互斥量未锁定的情况下进行
    std::this_thread::sleep_for(std::chrono::seconds(1));
 
    // 重新锁定互斥量
    lock.lock();
    std::cout << "Worker thread has re-locked the mutex." << std::endl;
}
 
int main() {
    std::thread t(worker);
 
    // 主线程等待一段时间，以确保worker线程首先运行
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
 
    {
        std::unique_lock<std::mutex> lock(mtx);
        std::cout << "Main thread has locked the mutex." << std::endl;
    }
 
    t.join();
    return 0;
}

在这个例子中，worker 函数中的线程首先通过 std::unique_lock 锁定互斥量，然后手动调用 unlock() 解锁它。接下来，线程模拟一些工作（在此期间互斥量处于未锁定状态），然后再次调用 lock() 重新锁定互斥量。

这种能力对于需要在临界区内执行一部分工作后释放互斥量，然后再进入另一个临界区的场景非常有用。需要注意的是，手动解锁和重新锁定增加了代码的复杂性，因此应谨慎使用，以避免引入竞争条件或死锁等问题。