C++ 11中lock_guard和unique_lock的区别

目录

• 一、功能设计
• 1.1 std::lock_guard
• 1.2 std::unique_lock 
• 二、构造方式
• 2.1 std::lock_guard 
• 2.2 std::unique_lock
• 三、解锁能力
• 3.1 std::lock_guard
• 3.2 std::unique_lock
• 四、与条件变量的配合
• 4.1 std::lock_guard 
• 4.2 std::unique_lock 
• 五、性能和开销
• 总结

在C++11中，std::lock_guard 和 std::unique_lock 都是用于管理互斥锁（std::mutex 或其他互斥锁类型）的RAII（资源获取即初始化）类，但它们在功能和使用场景上有一些重要的区别。以下是它们的主要区别：

一、功能设计

1.1 std::lock_guard

功能单一：std::lock_guard 的唯一目的是在构造时锁定互斥锁，并在析构时释放互斥锁。它不支持手动解锁。

使用场景：适用于需要在某个作用域内简单地锁定和解锁互斥锁的场景，且不需要中途解锁。

代码示例：

#include<thread>
#include<mutex>
std::mutex mt;
void function()
{
    // 构造lock对象时，锁定
    std::lock_guard<std::mutex> lock(mt);
    // 在这个作用域内，互斥锁保持锁定状态
    ...
    // lock 对象析构时，互斥锁自动解锁。     
}

1.2 std::unique_lock 

功能丰富：std::unique_lock 提供了更灵活的锁管理功能。它支持手动锁定和解锁，还可以在构造时不立即锁定互斥锁。

使用场景：适用于需要更灵活地控制锁的场景，例如在条件变量等待时需要解锁互斥锁，或者在某些条件下才锁定互斥锁。

代码示例：

#include<thread>
#include<mutex>
std::mutex mt;
void function()
{
    // 构造lock对象时，锁定
    std::unique_lock<std::mutex> lock(mt);
    // 手动解锁
    lock.unlock();
    // 在这个作用域内，互斥锁是解锁状态
    ...
    // 从新锁定
    lock.lock();
    // lock 对象析构时，互斥锁自动解锁。     
}

二、构造方式

2.1 std::lock_guard 

• 构造时必须传递一个互斥锁对象，并且会立即锁定该互斥锁。

构造函数：

 explicit lock_guard(_Mutex& _Mtx) : _MyMutex(_Mtx) { // construct and lock
     _MyMutex.lock();
 }

 lock_guard(_Mutex& _Mtx, adopt_lock_t) noexcept // strengthened
     : _MyMutex(_Mtx) {} // construct but don't lock

• 默认情况下，会立即锁定互斥锁。
• 如果传递了 std::adopt_lock，表示互斥锁已经被当前线程锁定，std::lock_guard 只负责管理锁的释放。

2.2 std::unique_lock

构造时可以选择不立即锁定互斥锁，或者传递一个已经锁定的互斥锁。

构造函数：

 _NODISCARD_CTOR_LOCK explicit unique_lock(_Mutex& _Mtx)
     : _Pmtx(_STD addressof(_Mtx)), _Owns(false) { // construct and lock
     _Pmtx->lock();
     _Owns = true;
 }

 _NODISCARD_CTOR_LOCK unique_lock(_Mutex& _Mtx, adopt_lock_t) noexcept // strengthened
     : _Pmtx(_STD addresshttp://www.devze.comof(_Mtx)), _Owns(true) {} // construct and assume already locked

 unique_lock(_Mutex& _Mtx, defer_lock_t) noexcept
     : _Pmtx(_STD addr编程客栈essof(_Mtx)), _Owns(falsejs) {} // construct but don't lock

• 默认情况下，不会立即锁定互斥锁（需要手动调用 lock()）。
• 如果传递了 std::defer_lock，表示延迟锁定，需要手动调用 lock()。
• 如果传递了 std::adopt_lock，表示互斥锁已经被当前线程锁定，std::unique_lock 只负责管理锁的释放。

三、解锁能力

3.1 std::lock_guard

• 不支持手动解锁。互斥锁只能在 std::lock_guard 对象析构时自动解锁。

3.2 std::unique_lock

• 支持手动解锁。可以通过调用 unlock() 方法手动释放互斥锁，也可以在析构时自动解锁。
• 代码示例：

std::unique_lock<std::mutex> lock(mtx, std::defer_lock); // 延迟锁定
lock.lock(); // 手动锁定
lock.unlock(); // 手动解锁

四、与条件变量的配合

4.1 std::lock_guard 

• 由于不支持手动解锁，因此不能与条件变量配合使用。条件变量需要在等待时释放互斥锁，并在被唤醒后重新锁定。

4.2 std::unique_loc编程k 

• 与条件变量配合使用时非常方便。std::unique_lock 可以在等待条件变量时手动解锁互斥锁，并在条件变量被唤醒后重新锁定。

#include<thread>
#include<mutex>
#include<conditPEuEFion_variable>
std::mutex mt;
std::condition_variable cv;
bool bReady = false;
// 生产者
void producer()
{
    // 构造lock对象时，锁定
    std::unique_lock<std::mutex> lock(mt);
   // Do Something
    ... 
    // 解锁
    lock.unlock();
   
    // 通知消费者
    cv.notify_one();
}

void customer()
{
    // 构造lock对象时，锁定
    std::unique_lock<std::mutex> lock(mt);
    // 条件变量等待时自动解锁和重新锁定
    cv.wait(lock,[]{return bReady;});
    // 继续处理
}

五、性能和开销

• std::lock_guard
  • 由于功能简单，通常比 std::unique_lock 更轻量级，生成的代码可能更高效。
• std::unique_lock
  • 功能更复杂，可能带来一些额外的开销，但这种开销在大多数情况下是可以忽略的。

总结

• 如果你只需要在某个作用域内简单地锁定和解锁互斥锁，且不需要中途解锁，那么 std::lock_guard 是更好的选择。
• 如果你需要更灵活地控制锁的锁定和解锁，或者需要与条件变量配合使用，那么 std::unique_lock 是更合适的选择。

到此这篇关于C++ 11中lock_guard和unique_lock的区别的文章就介绍到这了,更多相关C++ 11 lock_guard和unique_lock 内容请搜索编程客栈(www.devze.com)以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程客栈(www.devze.com)！