C++ 互斥锁与唯一锁

什么时候我应该更喜欢第一段代码而不是第二段代码，它们有根本的区别吗

std::mutex mtx;
mtx.lock();
... //protected stuff
mtx.unlock();
... //non-protected stuff
mtx.lock();
... //etc

及

std:：mutex-mtx；
标准：唯一锁定lck（mtx）；
... //受保护的东西
lck.unlock（）；
... //不受保护的东西
lck.lock（）；
... //等

---

我知道lock_guard基本上是一个没有锁定和解锁功能的独特的锁，但是我很难区分互斥锁和使用互斥锁的锁

是的，

std:：unique_lock

在其析构函数中调用互斥锁的解锁

这样做的好处是，如果引发了一些异常，您可以确保在离开定义了

std:：unique\u lock

的作用域时，互斥锁将解锁。

这样想：

// define a mutex
std::mutex mtx;

。。。很久以后

void something_safe()
{

  // code in these braces is a critical section
  {
    auto lock = std::unique_lock<std::mutex>(mtx); // equivalent to mtx.lock();
    ... //protected stuff
  }  // <---- however you leave this brace, equivalent to mtx.unlock();

  ... //non-protected stuff
}

void something\u safe（）
{
//这些大括号中的代码是一个关键部分
{
auto lock=std:：unique_lock（mtx）；//等效于mtx.lock（）；
…//受保护的东西
}//高度相关：因此不建议使用简单互斥，因为出现异常可能会导致锁出现问题，unique\u lock阻止了这一点？如果锁中的代码可以引发异常，那么是的。如果只锁定一次，并在最后解锁，那么std:：lock\u guard也会执行此任务，并且比std:：unique\u Lockd简单oesn没有回答任何问题。这篇文章的编辑队列已经满了，但本质上Richard想要得到的是一个唯一的\u锁，你不必显式地解锁互斥锁-当唯一的\u锁对象超出范围时，它就会解锁。
void something_safe()
{

  // code in these braces is a critical section
  {
    auto lock = std::unique_lock<std::mutex>(mtx); // equivalent to mtx.lock();
    ... //protected stuff
  }  // <---- however you leave this brace, equivalent to mtx.unlock();

  ... //non-protected stuff
}