C++ 无序映射：多线程插入？

我有一堆数据（一个介于0和ULLONG_MAX之间的巨大整数列表），我想提取所有唯一的值。我的方法是创建一个无序的映射，使用整数列表值作为键，使用一次性布尔值作为映射值。我迭代列表并为每个键插入一次性值。最后，我迭代映射以获得所有唯一的键。非常直截了当

然而，我的列表太大了（1亿），我想多线程处理这个过程。我知道一种简单的线程方法是行不通的，因为无序的_映射插入会影响底层数据结构，因此它不是线程安全的。在每次插入周围添加锁会很慢，并且可能会抵消任何线程加速

---

然而，大概不是每次插入都会改变数据结构（只有那些不能放入现有分配的存储桶中的数据结构？）。在插入之前，是否有方法检查特定插入是否需要无序的地图重新分配？这样，我只能在地图更改时锁定线程，而不是在每次插入时锁定。然后，在每次插入之前，线程仅检查是否存在锁…而不是执行完全锁定/解锁。这可能吗？

并行化的基本规则是将作业分解，处理各个部分，然后合并各个部分

散列/项查找是整个shebang中最昂贵的部分，所以这就是我们将重点关注的并行化

如果您确实需要将结果作为哈希表，我有一些坏消息告诉您：您必须自己编写。话虽如此，让我们开始吧

首先，让我们以串行方式解决这个问题。这很简单。下面的函数接受一个向量和一个回调。我们将获取向量，将其转换为

无序集

，并将

无序集

交给回调函数。简单？对

现在，因为我们要在一个线程上做这件事，我们不能马上做。相反，我们将返回一个不带参数的lambda。调用lambda时，它将创建

无序集

，并将其交给回调。这样，我们可以将每个lambda分配给它自己的线程，每个线程将通过调用lambda来运行作业

template<class Vector, class Callback>
auto lazyGetUnique(Vector& vector, Callback callback) {
    using Iterator = decltype(vector.begin());
    auto begin = vector.begin();
    auto end = vector.end();
    using elem_t = typename std::iterator_traits<Iterator>::value_type;

    //We capture begin, end, and callback
    return [begin, end, callback]() {
        callback(std::unordered_set<elem_t>(begin, end));
    };
}

假设我们想要得到一个向量的唯一元素，并将它们分配回该向量。这现在非常简单：

std::vector<int> v = /* stuff */;
auto new_thread = std::thread( lazyGetUnique(v, assignTo(v)) ); 

---

此函数将内容分解为4个块，每个块不相交。它在4个块中的每个块中找到唯一的元素，然后组合结果。输出是一个向量

您可以尝试构建多个容器，然后合并它们。首先，我将使用

unordered\u set:：reserve（）

查看是否真的需要多线程。你能用一个线程让它足够快吗？@SamVarshavchik很好地读了第三遍。我的问题不是stl容器是否是线程安全的。我的问题是，是否有方法可以使插入锁定更有效。包装好的容器可以是线程安全的，因此它们本身不是线程安全的这一事实是无关紧要的。@Miles，我的建议是使用

unordered_set:：reserve（）

和一个执行线程来确定多线程是否真的是必要的。我不会插入到集合（或映射）中，而是将块排序到位，并在块上使用

std:：unique

。然后将块合并在一起，并对结果使用

std:：unique

。大多数（尤其是排序）并行执行都很简单。谢谢您的编写！对我来说，最好的方法是根据每个数字的最后一位将值拆分为线程，这样可以确保没有两个线程对相同的值进行唯一性测试。有了这个过滤器，剩下的就变得简单多了。我将此作为答案，因为这是一个非常可行的解决方案。显然，最坏的情况是所有数字都被过滤到同一个线程中，但我的值分布相当均匀，所以我认为我不会遇到这个问题。

std::vector<int> v = /* stuff */;
auto new_thread = std::thread( lazyGetUnique(v, assignTo(v)) ); 

template<class Iterator>
auto getUnique(Iterator begin, Iterator end) {
    using elem_t = typename std::iterator_traits<Iterator>::value_type;

    std::vector<elem_t> blocks[4];

    //Split things up into blocks based on the last 4 bits
    //Of the number. This allows us to guarantee that no two blocks
    //share numbers. 
    for(; begin != end; ++begin) {
        auto val = *begin; 
        blocks[val & 0x3].push_back(val); 
    }

    //Each thread will run their portion of the problem.
    //Once it's found all unique elements, it'll stick the result in the block used as input
    auto thread_0 = std::thread( lazyGetUnique(blocks[0], assignTo(blocks[0])) );
    auto thread_1 = std::thread( lazyGetUnique(blocks[1], assignTo(blocks[1])) );
    auto thread_2 = std::thread( lazyGetUnique(blocks[2], assignTo(blocks[2])) );

    //We are thread_3, so we can just invoke it directly
    lazyGetUnique(blocks[3], assignTo(blocks[3]))(); //Here, we invoke it immediately

    //Join the other threads
    thread_0.join();
    thread_1.join();
    thread_2.join(); 

    std::vector<elem_t> result;
    result.reserve(blocks[0].size() + blocks[1].size() + blocks[2].size() + blocks[3].size());

    for(int i = 0; i < 4; ++i) {
        result.insert(result.end(), blocks[i].begin(), blocks[i].end());
    }

    return result;
}