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