C ++ 11中的async(launch :: async)是否会使线程池过时,以避免代价高昂的线程创build?

它与这个问题松散地相关: std :: thread是在C ++ 11中汇集的吗? 。 虽然问题不同,但意图是一样的:

问题1:使用自己的(或第三方库)线程以避免代价高昂的线程创build仍然有意义吗?

在另一个问题的结论是,你不能依靠std::thread汇集(它可能或可能不)。 然而, std::async(launch::async)似乎有更高的机会被汇集。

它不认为这是由标准强制的,但恕我直言,我希望所有好的C ++ 11实现将使用线程池,如果线程创build速度慢。 只有在创build新线程便宜的平台上,我才会期望它们总是产生一个新的线程。

问题2:这只是我的想法,但我没有事实可以certificate。 我很可能是错的。 这是一个受过教育的猜测吗?

最后,在这里,我提供了一些示例代码,首先显示了我认为线程创build可以通过async(launch::async)

例1:

  thread t([]{ f(); }); // ... t.join(); 

  auto future = async(launch::async, []{ f(); }); // ... future.wait(); 

示例2:启动并忘记线程

  thread([]{ f(); }).detach(); 

  // a bit clumsy... auto dummy = async(launch::async, []{ f(); }); // ... but I hope soon it can be simplified to async(launch::async, []{ f(); }); 

Questin 3:你会喜欢thread版本的async版本吗?


其余的不再是问题的一部分,只是为了澄清:

为什么必须将返回值分配给一个虚拟variables?

不幸的是,当前的C ++ 11标准强制你捕获std::async的返回值,否则析构函数会被执行,直到操作终止。 有些人认为这个标准是错误的(例如Herb Sutter)。

这个来自cppreference.com的例子很好地说明了这一点:

 { std::async(std::launch::async, []{ f(); }); std::async(std::launch::async, []{ g(); }); // does not run until f() completes } 

另一个解释:

我知道线程池可能有其他合法的用途,但在这个问题上,我只关心避免昂贵的线程创build成本

我认为仍然有线程池非常有用的情况,特别是如果您需要更多的资源控制。 例如,服务器可能决定只处理固定数量的请求,以确保快速的响应时间并提高内存使用的可预测性。 线程池应该很好,在这里。

线程局部variables也可能是你自己的线程池的一个参数,但是我不确定它在实践中是否相当可信:

  • std::thread创build一个新的线程,不用初始化的线程局部variables。 也许这不是你想要的。
  • async产生的线程中,对于我来说有些不清楚,因为线程可能已被重用。 从我的理解,线程局部variables不保证被重置,但我可能是错的。
  • 另一方面,使用自己的(固定大小)线程池,如果真的需要,可以完全控制它。

One Solution collect form web for “C ++ 11中的async(launch :: async)是否会使线程池过时,以避免代价高昂的线程创build?”

问题1

我改变了原来的,因为原来是错的。 我的印象是, Linux线程创build非常便宜 ,经过testing,我确定线程函数调用的开销与普通函数的开销是巨大的。 一个线程调用比10000或更慢一些。 所以,如果你发出很多小函数调用,一个线程池可能是一个好主意。

很显然,使用g ++的标准C ++库没有线程池。 但我绝对可以看到他们的情况。 即使不得不通过某种线程间队列推送呼叫,开销也可能比开始一个新线程便宜。 而标准允许这样做。

恕我直言,Linux内核的人应该努力使线程创build比现在更便宜。 但是,标准的C ++库也应该考虑使用pool来实现launch::async | launch::deferred launch::async | launch::deferred

而且OP是正确的,使用::std::thread来启动一个线程当然会强制创build一个新的线程,而不是从一个池中使用一个线程。 所以::std::async(::std::launch::async, ...)是首选。

问题2

是的,基本上这个“暗中”启动了一个线程。 但是真的,现在还是很明显的。 所以我不认为这个词含蓄地是一个特别好的词。

我也不相信,迫使你在破坏之前等待回报肯定是一个错误。 我不知道你应该使用async调用来创build预计不会返回的守护进程线程。 如果他们预计会返回,那么忽略例外是不可行的。

问题3

就我个人而言,我喜欢线程启动是明确的。 我在岛上放置了很多价值,你可以保证串行访问。 否则,最终会出现可变状态,你总是要在某个地方包装一个互斥体,并记住要使用它。

我喜欢工作队列模型比“未来”模型好得多,因为有“串联岛”,所以你可以更有效地处理可变状态。

但是,真的,这取决于你在做什么。

性能testing

因此,我testing了各种调用方法的性能,并在运行Fedora 25的2 CPU虚拟机上使用g ++ 6.3.1进行编译:

Do nothing calls per second: 30326536 Empty calls per second: 29348752 New thread calls per second: 15322 Async launch calls per second: 14779 Worker thread calls per second: 1357391

和本机,在我的MacBook视网膜Apple LLVM version 8.0.0 (clang-800.0.42.1)在OSX Apple LLVM version 8.0.0 (clang-800.0.42.1)下,我得到这个:

Do nothing calls per second: 20303610 Empty calls per second: 20222685 New thread calls per second: 40539 Async launch calls per second: 45165 Worker thread calls per second: 2662493

对于工作线程,我启动了一个线程,然后使用一个无锁队列将请求发送到另一个线程,然后等待“完成”回复被发回。

“什么都不做”只是为了testingtesting工具的开销。

很明显,启动线程的开销是巨大的。 即使是线程间队列的工作者线程也会在VM中减less20倍左右的Fedora 25,在本机OS X上减less大约8倍。

我创build了一个持有我用于性能testing的代码的Bitbucket项目。 它可以在这里find: https : //bitbucket.org/omnifarious/launch_thread_performance

  • CompletableFuture,Future和RxJava的Observable之间的区别
  • 如何在Java中使用单独的线程调用方法?
  • 一个程序可以同时调用同一个FILE *上的fflush()吗?
  • 在Python中正确使用互斥
  • multiprocessing.Pool:何时使用apply,apply_async或map?
  • 私人构造函数,以避免竞争条件
  • 如何创buildLooper线程,然后立即发送消息?
  • 在Java中编程死锁检测
  • 如何在Clojure中启动一个线程?
  • 在调用condition_variable.notify_one()之前是否必须获取locking?
  • 如何检测和debuggingmultithreading问题?