C++ boost线程互斥数组

我的问题是，我用多个线程更新了块矩阵。 多个线程可能一次更新不相交的块，但通常可能存在争用条件。现在矩阵是使用单锁锁定的

问题是，这可能吗（如果可能，怎么可能？） 实现一个高效的锁数组，以便一次只能锁定矩阵的一部分

所讨论的矩阵可能会变得相当大，大约50^2个块。我最初的猜测是使用动态分配向量/互斥映射

这是个好办法吗？ 使用多个条件变量是否更好？

---

有更好的方法吗？

您可以使用以下几种方法：

如果CriticalSection/Mutex（2500不是那么多）预先分配数组，并使用块索引作为锁索引来收集块访问；在更新块之前，锁定所有要更改的块；做更新；解锁

若计算时间明显长于Lock/Unlock，那个么在线程上下文中复制块的内容，并在这段时间内保持块解锁；在更新块之前，再次锁定它，并确保它没有被另一个线程更新（如果与此相关）；如果它被另一个线程更新，则重复操作

如果块内容的大小较小，则使用原子数据交换来更新块内容，无需锁定；只是不确定是否使用一个块中的数据来计算另一个块的数据，在这种情况下，需要在所有更新的块之间锁定

矩阵上是否有读取操作？如果是，则使用读/写锁来提高性能

---

使用一把锁。但不是用它来保护整个矩阵，而是用它来保护表示哪些块被“锁定”的

std:：set

（或

boost:：unordered_set

）

像这样的

class Block;

class Lock_block
{
public:
   Lock_block( Block& block ) : m_block(&block)
   {
      boost::unique_lock<boost::mutex> lock(s_mutex);
      while( s_locked.find(m_block) != s_locked.end() )
      {
         s_cond.wait(lock);
      }
      bool success = s_locked.insert(m_block).second;
      assert(success);
   }

   ~Lock_block()
   {
      boost::lock_guard<boost::mutex> lock(s_mutex);
      std::size_t removed = s_locked.erase(m_block);
      assert(removed == 1);
      s_cond.notify_all();
   }
private:
   Block* m_block;

   static boost::mutex s_mutex;
   static boost::condition s_cond;
   static std::set<Block*> s_locked;
};

类块；
类锁块
{
公众：
锁定块（块和块）：m块和块
{
boost：：唯一的_锁（s_互斥）；
while（s_locked.find（m_block）！=s_locked.end（））
{
秒等待（锁定）；
}
bool success=s_locked.insert（m_block）.second；
断言（成功）；
}
~Lock_block（）
{
boost:：lock\u guard lock（s\u互斥锁）；
std:：size\u t removed=s\u locked.erase（m\u块）；
断言（删除==1）；
s_cond.notify_all（）；
}
私人：
块*m_块；
静态boost：：mutex s_mutex；
静态增压：条件s_cond；
静态标准：：设置s_锁定；
};

您是否总是在程序中使用同一个矩阵？或者它是一系列矩阵（如视频处理）？这确实更简单。非常感谢。