C++ 11中的async(launch :: async)是否会使线程池过时以避免昂贵的线程创建?

Phi*_*ßen 109 c++ multithreading asynchronous threadpool c++11

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

问题1:使用您自己的(或第三方库)线程池以避免昂贵的线程创建仍然有意义吗?

另一个问题的结论是你不能依赖于std::thread汇集(可能或可能不是).但是,std::async(launch::async)似乎有更高的机会被汇集.

它不认为它是由标准强制,但恕我直言,如果线程创建缓慢,我会期望所有好的C++ 11实现都会使用线程池.只有在创建新线程成本低廉的平台上,我才会期望它们总是产生一个新线程.

问题2:这正是我的想法,但我没有事实证明这一点.我很可能会弄错.这是一个有根据的猜测吗?

最后,在这里我提供了一些示例代码,首先展示了我认为线程创建如何表达async(launch::async):

例1:

 thread t([]{ f(); });
 // ...
 t.join();
Run Code Online (Sandbox Code Playgroud)

 auto future = async(launch::async, []{ f(); });
 // ...
 future.wait();
Run Code Online (Sandbox Code Playgroud)

示例2:消防和遗忘线程

 thread([]{ f(); }).detach();
Run Code Online (Sandbox Code Playgroud)

 // a bit clumsy...
 auto dummy = async(launch::async, []{ f(); });

 // ... but I hope soon it can be simplified to
 async(launch::async, []{ f(); });
Run Code Online (Sandbox Code Playgroud)

问题3:您希望async版本的thread版本?


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

为什么必须将返回值赋给虚拟变量?

不幸的是,当前的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
}
Run Code Online (Sandbox Code Playgroud)

另一个澄清:

我知道线程池可能有其他合法用途,但在这个问题中,我只对避免昂贵的线程创建成本感兴趣.

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

线程局部变量也可能是您自己的线程池的参数,但我不确定它在实践中是否相关:

  • 使用std::thread启动创建一个没有初始化的线程局部变量的新线程.也许这不是你想要的.
  • 在产生的线程中async,对我来说有点不清楚,因为线程可以被重用.根据我的理解,线程局部变量不能保证被重置,但我可能会弄错.
  • 另一方面,使用您自己的(固定大小)线程池,如果您确实需要它,可以完全控制它.

Omn*_*ous 45

问题1:

我从原来改变了这个,因为原来是错的.我的印象是Linux线程创建非常便宜,经过测试后我确定新线程中的函数调用与正常线程的开销是巨大的.创建一个处理函数调用的线程的开销比普通函数调用慢10000或者多一倍.所以,如果你发出了很多小函数调用,那么线程池可能是个好主意.

很明显,随g ++提供的标准C++库没有线程池.但我绝对可以看到他们的情况.即使有必须通过某种线程间队列推送调用的开销,它也可能比启动新线程更便宜.而标准允许这样做.

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

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

问题2:

是的,基本上这个"含蓄地"启动一个线程.但实际上,发生的事情仍然非常明显.所以我并不认为隐含的这个词是一个特别好的词.

我也不相信在破坏之前迫使你等待回归必然是一个错误.我不知道你应该使用这个async调用来创建不希望返回的'守护进程'线程.如果他们被期望返回,那么忽略异常就不行了.

问题3:

就个人而言,我喜欢线程发布是明确的.我非常重视岛屿,你可以保证串行访问.否则你最终会遇到可变状态,你总是需要在某个地方包装一个互斥锁并记住要使用它.

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

但实际上,这取决于你正在做什么.

性能测试

所以,我测试了各种调用方法的性能,并在运行Fedora 25的2 CPU VM上用g ++ 6.3.1编写了这些数字:

Apple LLVM version 10.0.0 (clang-1000.10.44.4)

原生,launch::async | launch::deferred在OSX 10.12.3的MacBook Retina上,我得到了这个:

::std::thread

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

"无所事事"只是为了测试测试工具的开销.

很明显,启动线程的开销很大.甚至具有线程间队列的工作线程也会使VM中的Fedora 25减少20左右,而本机OS X上的大约减少8.

我创建了一个Bitbucket项目,其中包含我用于性能测试的代码.它可以在这里找到:https://bitbucket.org/omnifarious/launch_thread_performance

  • 在第一部分中,您在某种程度上低估了创建威胁所要做的工作,以及调用函数所要做的事。函数调用和返回是一些CPU指令,它们操纵堆栈顶部的几个字节。威胁创建意味着:1.分配堆栈,2.执行系统调用,3.在内核中创建数据结构并将其链接,沿途获取锁,4.等待调度程序执行线程,5.切换线程的上下文。这些步骤本身比最复杂的函数调用所需的时间长得多。 (3认同)
  • 我同意工作队列模型,但是这需要一个"管道"模型,它可能不适用于并发访问的每次使用. (2认同)
  • “非常便宜”与您的经历有关。我发现使用Linux线程创建的开销为_substantial_。 (2认同)
  • @Omnifarious 一个函数调用大约需要 20 个 CPU 周期(你测量得更少,因为一些开销隐藏在你的测试工具后面)。一次内存分配很容易占用 200 个 CPU 周期。一个系统调用不少于 200ns。获取锁是威胁间的通信,需要在内核中执行,预计大约为微秒。而且我还没有开始设置页表或刷新 TLB 的开销。如果专用硬件允许更快地创建线程,那是因为硬件已为此进行了优化,而 X86 CPU 则不然。 (2认同)