C++ 11中lock_guard和unique_lock的区别

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

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

 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

 _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 addressof(_Mtx)), _Owns(true) {} // construct and assume already locked

 unique_lock(_Mutex& _Mtx, defer_lock_t) noexcept
     : _Pmtx(_STD addressof(_Mtx)), _Owns(false) {} // construct but don't lock

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

#include<thread>
#include<mutex>
#include<condition_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;});
    // 继续处理
}