C ++中的多线程读取多，写入很少的数组/向量迭代

Question

我需要以只读方式几乎不断地迭代一系列结构，但对于每 1M+ 次读取，其中一个线程可能会附加一个项目。我认为在这里使用互斥锁会有点矫枉过正，我还在某处读到读/写锁对读者有其自身的缺点。

我正在考虑在 std::vector 上使用 reserve() 但这个答案 Iterate over STL container using indices safe way to avoid using locks? 似乎无效。

关于哪种方式可能最快的任何想法？最重要的是让读者能够在尽可能少的争用情况下快速有效地进行迭代。写入操作对时间不敏感。

更新：我的另一个用例是“列表”可以包含指针而不是结构。即，std::vector。同样的要求也适用。

更新 2：假设示例

全球可访问：

typedef std::vector<MyClass*> Vector;
Vector v;
v.reserve(50);

阅读器线程 1-10：（这些线程几乎一直在运行）

.
.
int total = 0;
for (Vector::const_iterator it = v.begin(); it != v.end(); ++it)
{
   MyClass* ptr = *it;
   total += ptr->getTotal();
}
// do something with total
.
.

编写器线程 11-15：

MyClass* ptr = new MyClass();
v.push_back(ptr);

这基本上就是这里发生的事情。线程 1-15 都可以同时运行，尽管通常只有 1-2 个读取线程和 1-2 个写入线程。

Answer 1

我认为可以在这里工作的是 vector 的自己的实现，如下所示：

template <typename T> class Vector
{
// constructor will be needed of course
public:
    std::shared_ptr<const std::vector<T> > getVector()
        { return mVector; }
    void push_back(const T&);

private:
    std::shared_ptr<std::vector<T> > mVector;
};

然后，当读者需要访问特定的Vector 时，他们应该调用getVector() 并保留返回的shared_ptr 直到完成阅读。

但作者应该始终使用Vector 的push_back 来增加新价值。然后这个push_back 应该检查mVector.size() == mVector.capacity() 是否为真，如果为真，分配new vector 并将其分配给mVector。比如：

template <typename T> Vector<T>::push_back(const T& t)
{
    if (mVector->size() == mVector->capacity())
    {
        // make certain here that new_size > old_size
        std::vector<T> vec = new std::vector<T> (mVector->size() * SIZE_MULTIPLIER);

        std::copy(mVector->begin(), mVector->end(), vec->begin());
        mVector.reset(vec);
    }
// put 't' into 'mVector'. 'mVector' is guaranteed not to reallocate now.
}

这里的想法受到 RCU（读取-复制-更新）算法的启发。如果存储空间用尽，只要至少有一个读取器访问新存储，就不应使旧存储失效。但是，应该分配新的存储，并且分配后的任何读者都应该能够看到它。一旦没有人再使用旧存储，就应该释放它（所有读取器都已完成）。

由于大多数硬件架构都提供了一些原子增量和减量的方法，我认为shared_ptr（因此Vector）将能够完全无锁地运行。

不过，这种方法的一个缺点是，根据读者持有 shared_ptr 的时间长短，您最终可能会收到多个 data 的副本。

PS：希望我没有在代码中犯太多尴尬的错误:-)

Answer 2

... 在 std::vector 上使用 reserve() ...

这只有在你能保证向量永远不需要增长的情况下才有用。您已声明如果项目的数量没有在上面，因此您无法提供该保证。

尽管有链接的问题，但您可以想象使用 std::vector 只是为您管理内存，但要解决已接受答案中确定的问题，需要额外的逻辑层。

---

实际答案是：最快的做法是尽量减少同步量。同步的最小量是多少取决于你没有指定的代码和使用细节。

---

例如，我使用固定大小块的链表绘制了一个解决方案。这意味着您的常见用例应该与数组遍历一样高效，但您可以动态增长而无需重新分配。

然而，实现对以下问题很敏感：

• 是否需要删除项目
  • 无论何时阅读？
  • 只能从前面还是从其他地方？
• 如果容器是空的，是否要让阅读器忙-等待
  • 这是否应该使用某种退避方式
• 需要什么程度的一致性？