Question

从容器类，我希望lock boost::mutex的向量，每个受控实例拥有一个（奇怪的代码设计，但仅限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的开头，以锁定所有内容和 asap ，例如

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周期结束后，锁会很快就会超出范围。

我已经尝试new Container ctor的一系列锁定，并试图将delete放在它的dtor上，但我想这是违反RAII的习惯用法本身。

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

Answer 1

假设您的问题是：“如何同时为多个互斥锁使用类似RAII的范围锁？”

然后，您可以为多个锁创建自己的RAII包装器，也可以使用scope guard之类的东西。

（未经测试的伪代码，但希望你明白这一点。）

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

<强> Live On 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);
}

boost :: scoped_lock RAII行为

3 个答案: