c++ - 具有不可复制的 boost::mutex 的类的赋值运算符

Question

我在这里读这个旧的Boost Thread FAQ其中有为具有 boost::mutex 不可复制对象作为成员的类实现复制构造和赋值运算符的指南。

我对复制构造函数没意见，但我对赋值运算符有些怀疑。下面的指令还有效吗？

  // old boost thread    
  const counter & operator=( const counter& other ){
     if (this == &other)
        return *this;

     boost::mutex::scoped_lock lock1(&m_mutex < &other.m_mutex ?
                                        m_mutex : other.m_mutex);
     boost::mutex::scoped_lock lock2(&m_mutex > &other.m_mutex ?
                                        m_mutex : other.m_mutex);
     m_value = other.m_value;

     return *this;
}

这不应该更新为:

 // new boost thread    
 const counter& operator=(const counter& other){
    if (this == &other)
       return *this;

    boost::unique_lock<boost::mutex> l1(m_mutex, boost::defer_lock);
    boost::unique_lock<boost::mutex> l2(other.m_mutex, boost::defer_lock);
    boost::lock(l1,l2);
    m_value = other.m_value;

    return *this;
}

Answer 1

首先，我假设问题是关于在锁定多个任意互斥锁时避免死锁。重要的是始终使用一组互斥体在整个代码中使用相同 排序约定。如果你能保证互斥锁 A 总是先于 B，B 总是先于 C，A 总是先于 C，你就可以避免死锁。

在第一个代码示例中，惯例是首先锁定具有较低内存地址的互斥锁。这会很好地工作，因为地址排序是不变的。第二个版本是 official Boost method避免死锁。该文档未指定内部执行的排序。我不建议在源代码中查找它并在您的代码中的其他地方使用此信息 - 如果库发生变化，它可能会巧妙地破坏一些东西。

如果您是从头开始(您之前在代码中一次持有的互斥锁不超过一个)，那么使用 Boost 的方法绝对更可取——您不必担心确切的顺序，只要你每次都让它提升。如果您的其余代码使用内存排序，您必须使用它。如果您的代码完全使用其他约定，您也需要在此处应用它。在任何情况下，您都不应在可能同时持有的任何一组锁中混合约定，这只会带来麻烦。

回答评论中的问题:

自定义锁排序方案在某些情况下很有用，特别是如果您需要长时间持有一些锁 (A)，而一些锁 (B) 只是短暂持有，同时持有很长时间一。例如，如果您需要在 A 类型的对象上运行长时间的作业，这会短暂地影响 B 的许多实例。惯例是始终先获取 A 的锁，然后获取 B 的锁对象:

void doStuff(A& a, std::list<B*> bs){  boost::unique_lock<boost::mutex> la(a.mutex); // lock a throughout  for (std::list<B*>::iterator ib = bs.begin(); ib != bs.end(); ++ib)  {    // lock each B only for one loop iteration    boost::unique_lock<boost::mutex> lb(ib->mutex);    // work on a and *ib    // ...  }}

您可能能够在每次循环迭代之间放弃对 A 的锁定并使用 Boost 的/C++0x 的锁定顺序，但是根据 doStuff() 的作用，这可能会使算法更复杂或困惑。

另一个例子:在对象不一定位于同一内存位置的运行时环境中(例如，由于复制垃圾收集)，依赖内存地址进行排序是不可靠的。因此，您可以为每个对象提供一个唯一的 ID，并根据 ID 顺序进行锁定排序。