std::forward_list::insert_after 线程安全

Question

在共享的std::forward_list 中，如果多个线程保证永远不会使用相同的位置迭代器调用insert_after，它们是否安全？鉴于插入保证不会使其他迭代器无效，并且容器没有 size() 方法，这似乎是安全的，但也许我遗漏了什么？

编辑：

我写了一个小的酷刑测试程序，它似乎在 Clang 中运行良好，没有任何锁定：

#include <forward_list>
#include <iostream>
#include <thread>
#include <vector>

using List = std::forward_list< int >;
using It = List::const_iterator;

void insertAndBranch (List& list, It it, int depth)
{
    if (depth-- > 0) {
        It newIt = list.insert_after (it, depth);
        std::thread thread0 ([&]{ insertAndBranch (list, it, depth); });
        std::thread thread1 ([&]{ insertAndBranch (list, newIt, depth); });
        thread0.join();
        thread1.join();
    }
}

int main()
{
    List list;
    insertAndBranch (list, list.before_begin(), 8);

    std::vector< It > its;
    for (It it = list.begin(); it != list.end(); ++it) {
        its.push_back (it);
    }
    std::vector< std::thread > threads;
    for (It it : its) {
        threads.emplace_back ([&]{ list.insert_after (it, -1); });
    }
    for (std::thread& thread : threads) {
        thread.join();
    }

    for (int i : list) {
        std::cout << i << ' ';
    }
    std::cout << '\n';
}

我知道这并不能证明什么，但它让我希望这是安全的。不过，我不确定是否可以在没有标准确认的情况下使用它。

Answer 1

在共享的std::list 中，多个线程调用插入是否安全 同时，如果他们保证永远不会以相同的方式调用它 位置迭代器？

没有。这不安全……（无论如何）。

插入std::list 需要访问迭代器位置的previous node 和next node，以及列表的size。

即使位置相距很远，std::list::size() 的简单事实也需要恒定时间 (C++11)。这意味着每次插入都会更新std::list::size()。

---

编辑：

在共享的std::forward_list 中，多个线程可以安全吗？ 如果保证永远不会调用它，则同时调用 insert_after 使用相同的位置迭代器？

这不安全。并且不推荐。没有为 STL 容器设计线程安全。

---

无论如何，让我们假设一些基本的保证，让我们假设std::forward_list 的一个非常简单的版本：insert_after 修改了迭代器指向的节点，以便该节点现在指向新插入的节点，而新插入的节点指向下一个节点。因此，只有当迭代器彼此相距至少两个节点并且您的分配器是线程安全的时，它才会是“安全的”。

插图：

Initial Forward_list
A -> B -> C -> D -> E

Insert K after C
A -> B -> C x D -> E
           \ /
            K

如您所见，C 已被读取和修改。可以读取D，而插入K。

---

至于为什么我说“至少两个节点离开”，让我们以一个节点离开的情况为例：假设两个线程分别想在C之后插入K，在D之后分别插入M：

Initial Forward_list
A -> B -> C -> D -> E

Insert K after C
A -> B -> C x D x E
           \ / \ /
            K   M

来自cppreference：

当一个表达式的求值写入一个内存位置并且 另一个评估读取或修改相同的内存位置， 表达式被称为冲突。

Answer 2

当另一个线程 写入 到列表时，甚至 读取 操作都不是线程安全的（请参阅here 以获得进一步的解释）；所以：多次写入不是线程安全的：

虽然从没有锁的列表中读取不会损坏列表，但如果在另一个线程正在读取列表时修改了列表，则任何一个线程都可能损坏（即崩溃或产生不正确的结果）。 em>

您需要某种锁定。期间。