问题标签 [stdthread]

可能重复：
C++ 2011：std::thread：并行循环的简单示例？

考虑以下将计算分布在向量元素上的程序（我以前从未使用过 std::thread ）：

代码中已经嵌入了两个问题。

第三个问题是：这段代码完全没问题，还是可以使用 std::threads 以更优雅的方式编写？我不知道使用 std::thread 的“良好做法”...

我是 std::thread 的新手，我尝试编写一个parallel_for. 我编码了以下内容：

但这不起作用：（来自 g++ 4.6 的错误代码）

如何解决这个问题呢 ？

编辑：这个新版本编译但没有给出好的结果：

结果是：

并行版本返回 4950，而顺序版本返回 155..... 问题出在哪里？

可能重复：
并行使用 std::thread？

考虑以下实现 a 的代码parallel_for：

在 ideone（http://ideone.com/GrYJsQ）上它给出：

而在我使用 g++ 4.6 的计算机上，它给出 (g++ -O3 -std=c++0x parallel_for.cpp -o parallel_for -lpthread和./parallel_for) ：

问题出在哪里 ？

如果我是对的，std::async 使用一个新线程并调用其中的方法。我想知道如果主线程或父线程死了会发生什么。控制异步方法的线程是否也会死亡。

有没有办法在 std::async 方法中实现超时，所以如果线程在指定的时间内没有完成，我希望这个调用超时并完成。我怎样才能实现这个功能。

输出窗口显示：（VC++ 编译器版本：2012 年 11 月 CTP）

我正在尝试了解如何使用 Visual Studio 2012 使用新的 std::thread。我正在尝试编译以下代码。

我收到一条警告，上面写着警告 C4930: 'scoped_thread t(std::thread (__cdecl *)(local_functor))': 未调用原型函数（是否打算定义变量？）

是的，这是一个预期的变量定义。我该怎么做？

是否可以对我们需要使用线程跨越的函数进行重载？

我有一个名为 Complex 的简单类。

构建此代码时出现错误。

如果没有采用无符号的重载显示函数，那么我显示的代码可以正常工作。

我正在尝试建立一些启发式方法来帮助我决定std::thread要使用的适当类。

据我了解，从最高级别（使用最简单，但最不灵活）到最低级别，我们有：

1. std::async with/std::future (std::shared_future) （当你想在一次性的生产者线程异步上执行时）
2. std::packaged_task （当您想分配生产者，但将调用推迟到线程时）
3. std::promise (???)

我想我对何时使用前两个有一个不错的把握，但我仍然不清楚std::promise.

std::future与std::async调用一起，有效地将产生回调/仿函数/lambda 转换为异步调用（根据定义，它立即返回）。单个消费者可以调用std::future::get()阻塞调用来获取结果。

std::shared_future只是一个允许多个消费者的版本。

如果您想将std::future值与生产者回调绑定，但希望将实际调用推迟到以后（当您将任务与生成线程相关联时），std::packaged_task这是正确的选择。但是现在，由于对应std::future的std::package_task可以，在一般情况下，可以被多线程访问，我们可能不得不小心使用 a std::mutex。请注意std::async，在第一种情况下，我们不必担心锁定。

阅读了一些关于 promise 的有趣链接后，我想我了解它的机制以及如何设置它们，但我的问题是，你什么时候会选择使用 Promise 而不是其他三个？

我正在寻找更多应用程序级别的答案，例如经验法则（在上面的 3. 中填写 ???），而不是链接中的答案（例如，使用 std::promise 来实现一些库机制），因此我可以更轻松地向std::thread.

换句话说，如果有一个有用的例子来说明我可以用其他机制做不到的事情，std::promise那就太好了。

回答

Astd::future是一个奇怪的野兽：一般来说，你不能直接修改它的值。

三个可以修改其值的生产者是：

1. std::async通过异步回调，它将返回一个std::future实例。
2. std::packaged_task，当传递给线程时，将调用其回调，从而更新std::future与该 关联的实例std::packaged_task。这种机制允许生产者的早期绑定，但稍后调用。
3. std::promise，它允许一个人std::future通过它的set_value()调用来修改它的关联。通过这种对变异 a 的直接控制std::future，如果有多个生产者（根据需要使用），我们必须确保设计是线程安全的std::mutex。

我认为塞思卡内基的回答是：

一种简单的思考方式是，您可以通过返回值或使用承诺来设置未来。future 没有设置方法；该功能由 promise 提供。

有助于阐明何时使用 Promise。但是我们必须记住，astd::mutex可能是必要的，因为根据使用情况，promise 可能可以从不同的线程访问。

此外，大卫的罗德里格斯的回答也很出色：

通信通道的消费者端将使用 std::future 来使用来自共享状态的数据，而生产者线程将使用 std::promise 来写入共享状态。

但作为替代方案，为什么不简单地std::mutex在 stl 结果容器上使用 a ，并使用一个线程或生产者线程池对容器进行操作？除了一些额外的可读性与 stl 结果容器之外，使用std::promise，相反，给我买了什么？

版本中的控制似乎更好std::promise：

1. wait() 将阻塞给定的未来，直到产生结果
2. 如果只有一个生产者线程，则不需要互斥锁

以下 google-test 通过了 helgrind 和 drd，确认使用单个生产者并使用 wait()，不需要互斥锁。

测试

我想检查 astd::thread是否已完成执行。搜索 stackoverflow 我发现以下问题解决了这个问题。接受的答案建议让工作线程在退出之前设置一个变量并让主线程检查这个变量。这是此类解决方案的最小工作示例：

对已接受的答案发表评论的人声称，不能使用简单的bool变量作为信号，代码在没有内存屏障的情况下被破坏并且使用std::atomic<bool>是正确的。我最初的猜测是这是错误的，一个简单bool的就足够了，但我想确保我没有遗漏任何东西。上面的代码是否需要astd::atomic<bool>才能正确？

让我们假设主线程和工作线程在不同套接字的不同 CPU 上运行。我认为会发生的是，主线程thread_finished从其 CPU 的缓存中读取。当 worker 更新它时，缓存一致性协议负责将 worker 更改写入全局内存并使主线程的 CPU 缓存无效，因此它必须从全局内存中读取更新的值。使上述代码正常工作的缓存一致性的全部意义不是吗？