boost :: scoped_lock RAII行为

Question

从Container类，我想lock boost::mutex的向量，每个向量都由Controlled实例拥有（奇怪的代码设计，但仅用于MWE）。

// std::vector<Controlled*> _vData;

void Container::main_method()
{
  for (int i=0; i<_vData.size(); i++)
  {
    boost::mutex::scoped_lock my_lock(_vData.at(i)->_mutex);
    this->processing(i);
  }

  // precondition for post_processing(): all processing() calls done
  for (int i=0; i<_vData.size(); i++)
  {
    boost::mutex::scoped_lock my_lock(_vData.at(i)->_mutex);
    this->post_processing(i);
  }
}

但是由于processing是cpu绑定的，同时， 受控对象在其他地方也进行了修改，因此我想在scoped_lock的开头简单地执行一个循环的main_method ，以便锁定所有内容并尽快完成 ，例如

void Container::desired_main_method()
{
  for (int i=0; i<_vData.size(); i++)
  {
    boost::mutex::scoped_lock my_lock(_vData.at(i)->_mutex);
  }

  // locks destroyed here, aren't they ?

  for (int i=0; i<_vData.size(); i++)
  {
    this->processing(i);
  }

  for (int i=0; i<_vData.size(); i++)
  {
    this->post_processing(i);
  }
}

问题是，如果我很好地理解了RAII习惯用法和scoped_lock上下文，那么以这种方式，在for循环的锁定结束后，锁定将很快超出范围。

我曾尝试在Container ctor处new一系列锁，并在其dtor中delete它，但是我想这与RAII惯用语本身不符。

我误解了什么，或者如何重构整个问题？

Answer 1

假设您的问题是： “如何同时将RAII类作用域锁用于多个互斥锁？”

然后，您可以为多个锁创建自己的RAII包装器，也可以使用诸如范围保护器之类的东西。

（未经测试的伪代码，但希望您能理解。）

template <typename TIterator>
class multiple_lock_guard
{
private:
    TIterator _begin, _end;

    multiple_lock_guard(TIterator begin, TIterator end)
        : _begin{begin}, _end{end}
    {
        for(auto it = _begin; it != _end; ++it)
        {
            it->_mutex.lock();
        }
    }

    ~multiple_lock_guard()
    {
        for(auto it = _begin; it != _end; ++it)
        {
            it->_mutex.unlock();
        }
    }
};

您可以按以下方式使用它：

void Container::desired_main_method()
{
    multiple_lock_guard mlg(std::begin(_vData), std::end(_vData));

    for(int i = 0; i < _vData.size(); i++)
    {
        this->processing(i);
    }

    for(int i = 0; i < _vData.size(); i++)
    {
        this->post_processing(i);
    }
}

Answer 2

接下来呢？

void Container::desired_main_method()
{
  std::vector<boost::mutex::scoped_lock> locks;

  for (int i=0; i<_vData.size(); i++)
  {
    locks.emplace_back(_vData.at(i)->_mutex);
  }

  for (int i=0; i<_vData.size(); i++)
  {
    this->processing(i);
  }

  for (int i=0; i<_vData.size(); i++)
  {
    this->post_processing(i);
  }
}

Answer 3

您已经可以使用Boost Thread的免费功能扩展来原子地锁定延迟锁的集合：

• http://www.boost.org/doc/libs/1_61_0/doc/html/thread/synchronization.html#thread.synchronization.lock_functions.lock_range
• 可悲的是，c ++ 17没有提供这种重载http://en.cppreference.com/w/cpp/thread/lock

生活在Coliru

#include <boost/thread.hpp>
#include <vector>

struct X {
    boost::mutex mutable mx;
};

void foo(std::vector<X> const& xs) {

    std::vector<boost::unique_lock<boost::mutex> > locks;
    for (auto& x : xs) {
        locks.emplace_back(x.mx, boost::defer_lock);
    }

    boost::lock(locks.begin(), locks.end());

    // all locks held
}

int main() {
    std::vector<X> xs(10);
    foo(xs);
}