c++ std::async 字面上异步关于任务的线程分配

Question

我过去曾成功使用 std::async，但最近在检查一些新代码的保真度时，我运行遇到了一个让我难过的怪事。我确定应该有一个简单的解释和一个适当的解决方案，但我在任何地方都找不到关于它的讨论。

下面的一小段代码说明了这个问题：

#include <functional>
#include <thread>
#include <future>
#include <iostream>
#include <sstream>
#include <vector>
#include <algorithm>


int main(int argc, char **argv) {

    for (size_t delay = 0; delay < 2; delay++) {
        std::vector<std::future<std::string>> futures;
        for (size_t i = 0; i < 10; i++) {

            auto fut = std::async(std::launch::async, 
                [&i] () -> std::string
                {
                    std::stringstream ss;
                    ss << "work on number " << i << " " << std::this_thread::get_id();
                    return ss.str();
                }
            );
            if (delay == 1) {
                std::this_thread::sleep_for (std::chrono::milliseconds(10));
            }
            futures.push_back(std::move(fut));
        }

        // do not proceed until all threads are done
        std::for_each(futures.begin(), futures.end(), [](std::future<std::string>& fut) 
            {
                auto codeconf = fut.get();
                std::cout << codeconf << std::endl;
            }
        );
        std::cout << std::endl;
    }
}

没有延迟（即第一次通过外循环），一些循环元素（整数）被遗漏并且没有被分配给 thread/task，而其他循环元素被分配给超过一个线程。循环也运行s 超出了它的限制：

处理 4 号 139770383861504
处理 4 号 139770375468800
处理 4 号 139770367076096
处理 6 号 139770358683392
处理 5 号 139770350290688
处理 6 号 139770341897984
处理 7 号 139770333505280
处理 8 号 139770325112576
处理 10 号 139770248296192
处理 10 号 139770239903488

包括一个较小的延迟（10 毫秒）允许循环增量和线程按预期和预期对应——即循环增量和 task/thread 之间的一对一对应（完成顺序不没关系，当然，即使它们在这里是有序的）：

处理编号 0 139770239903488
处理 1 号 139770248296192
处理 2 号 139770325112576
处理 3 号 139770333505280
处理 4 号 139770383861504
处理 5 号 139770375468800
处理 6 号 139770367076096
处理 7 号 139770358683392
处理 8 号 139770350290688
处理 9 号 139770341897984

我的理解是，异步启动策略应该只获取与循环迭代对应的整数，将其提供给 lambda 函数，并在独立的 task/thread 上执行；它什么时候开始（基本上是立即的）和什么时候结束对循环的功能和逻辑并不重要。但是在这里，毫不拖延地，"async" 似乎非常字面地描述了循环迭代和任务之间的关系。

微小延迟解决方法是否合法？我有什么不明白的？

Answer 1

正如@RichardCritten 在评论中所说，让一个线程（主线程）写入 i 而其他线程正在读取它会导致未定义的行为。我不会试图弄清楚为什么输出是这样的，编译可以改变内存的顺序 stores/writes 可以随意改变而无需同步（互斥锁等）。

关于该主题的几个有用的演讲：

Herb Sutter 的 "atomic<> weapons"：http://channel9.msdn.com/Shows/Going+Deep/Cpp-and-Beyond-2012-Herb-Sutter-atomic-Weapons-1-of-2
Han's Boehm's "Threads and Shared Variables in C++11": http://channel9.msdn.com/Events/GoingNative/GoingNative-2012/Threads-and-Shared-Variables-in-C-11

Answer 2

Without the delay (i.e. first time through the outer loop), some loop-elements (integers) get missed and don't get assigned to a thread/task, while other loop elements get assigned to more than one thread

如果试图从在该循环中生成的另一个线程访问循环计数器，这是一个直接的危险信号。

在这种情况下，您的任务使用 对 i 的引用，它在主线程中递增（并最终销毁）。

您应该将 i 的 copy 传递给每个任务，以便该任务肯定会使用该迭代中 i 的任何值。

c++ std::async 字面上异步关于任务的线程分配

c++ std::async literally async with respect to thread assignment of tasks

c++

multithreading

asynchronous

std