1

我正在阅读“C++ Concurrency In Action”一书，对清单 6.1 中使用的互斥锁有一些疑问，代码片段如下：

void pop(T& value)
{
    std::lock_guard<std::mutex> lock(m);
    if(data.empty()) throw empty_stack();
    value=std::move(data.top());
    data.pop();
}
bool empty() const
{
    std::lock_guard<std::mutex> lock(m);
    return data.empty();
}

该pop方法锁定互斥体，然后调用空互斥体。但是互斥锁不是recursive_mutex，并且代码可以正常工作。std::mutex所以我怀疑和之间的实际区别是什么std::recursive_mutex。

4

2 回答 2

4

它正在调用data.empty()，这看起来像是来自数据成员的函数。empty和你展示的功能不一样。

如果是，这将是一个递归调用

bool empty() const
{
    std::lock_guard<std::mutex> lock(m);
    return data.empty();
}

什么都行不通。

于 2015-10-13T09:16:32.180 回答
3

好吧，recursive_mutex是为了……递归函数！

在某些操作系统中，两次锁定同一个互斥体可能会导致系统错误（其中，锁可能会被完全释放，应用程序可能会崩溃，实际上可能会发生各种奇怪和未定义的行为）。

看看这个（愚蠢的例子）

void recursivePusher(int x){
   if (x>10){
     return;
   }

   std::lock_guard<std::mutex> lock(m);
   queue.push(x);
   recursivePusher(x+1);

}

此函数递归递增x并将其推送到一些 sharedqueue中。正如我们上面谈到的——同一个锁可能不会被同一个线程锁定两次，但我们确实需要确保共享队列不会被多个线程改变。

一种简单的解决方案是将定位移到递归函数之外，但是如果我们不能这样做会发生什么？如果调用的函数是唯一可以锁定共享资源的函数会怎样？

例如，我的调用函数可能如下所示：

switch(option){

case case1: recursivly_manipulate_shared_array(); break;
case case2: recursivly_manipulate_shared_queue(); break;
case case3: recursivly_manipulate_shared_map(); break;

}

当然，您不会只锁定所有三个（shred_Array，shared_map，shared_queue），因为其中一个会被更改。

解决方案是使用std::shared_mutex：

void recursivePusher(int x){
   if (x>10){
     return;
   }

   std::lock_guard<std::recursive_mutex> lock(m);
   queue.push(x);
   recursivePusher(x+1);

}

如果同一个线程不需要递归锁定互斥锁，它应该使用常规std::mutex，就像在你的例子中一样。

PS。在您的代码段中，empty与T::empty. 调用data.empty()不调用empty 递归。

于 2015-10-13T09:16:25.547 回答