C++ c++；

在处理并发问题时，我经常使用

std:：unique\u lock

和

std:：lock\u guard

，两者都没有问题

我还扩展了

std:：mutex

，以便能够按如下方式使用它：

mutex.protect([](){
    // my protected code here
}) ;

它锁定互斥锁，并在lambda调用时释放互斥锁

---

boost或标准库中是否已经实现了类似的行为？

如果您只想在函数中的较小范围内执行保护代码，则无需编写自己的保护函数来扩展互斥体。您可以按如下操作，使用大括号创建本地作用域，当作用域退出时，互斥锁将以异常安全的方式自动解锁

double process_func() { 
// do some stuff
    { //start a new scope block
      std::lock_guard<my_mutex> g; // mutex is locked here.
      []() { } // your lambda that needs to be protected
    } // Mutex is released here.
// do more stuff
} 

double process_func（）{
//做点什么
{//启动一个新的作用域块
std:：lock\u guard g；//互斥锁在这里被锁定。
[]（）{}//需要保护的lambda
}//互斥在这里被释放。
//多做事
} 

当然，与自定义函数相比，这有一个缺点， 这是很难维持的。有人可以稍后再来，在不知道自己在做什么的情况下注入更多代码。

Boost Thread有以下功能：

您可以像预期的那样使用它：

std::mutex mx;

boost::with_lock_guard(mx, []{
    // protected stuff
});

它甚至支持通常的调用语义：

int foo(int,double) { return 42; }

// ...

int answer = boost::with_lock_guard(mx, foo, 3, 3.14);

仅手动标准库实现 您可以自己轻松添加这样的内容：

template <typename M, typename F, typename... Args> 
    auto my_with_lock_guard(M& mx, F&& f, Args&&... args) {
        std::lock_guard<M> lk(mx);
        return std::forward<F>(f)(std::forward<Args>(args)...);
    }

模板
使用锁定保护（M&mx、F&F、参数和…参数）自动设置我的参数{
标准：锁紧装置lk（mx）；
返回std:：forward（f）（std:：forward（args）…）；
}

---

如果标准采纳了这样的建议，你可以很容易地将其替换掉。

这是我过去常做的事，但出于任何原因，我觉得这种方法很不吸引人，我正在寻找一种更简单的方法，但我希望避免跳出标准。我在标准锁或独特锁中看不到它。我不认为使用protect（）方法扩展它有任何缺点。如果我是你，我要测试的一件事就是新的std:：lock，它接受多个可锁定项，并锁定全部或全部，以避免死锁。但是，只要扩展了所有原始的lock（）、unlock（）、try_lock（）方法，就应该很好。我在标准中也没有看到它。我真的不喜欢扩展这样的低级对象，但正如您所注意到的，这并没有改变其他锁定方法。@Falco关键是要认识到扩展类型并不意味着添加成员。看起来很完美，完全符合我的需要。我在搜索过程中错过了这个boost功能。这还有一个优点，就是避免了std:：lock_guard的一个常见错误，即在使用它时没有声明变量。我相信您的手动实现需要C++14，否则，我会收到错误消息：

error:'with_lock_guard'函数使用'auto'类型说明符，而不带尾随的返回类型auto with_lock_guard（M&mx、F&&F、Args&&…Args）{^

..

注意：推导的返回类型仅在-std=c++14或-std=gnu++14时可用。当然，只需指定c++11的返回类型即可