C + + 11中的异步(启动: : 异步)是否会使线程池过时,从而避免昂贵的线程创建?

它与 在 C + + 11中是否有 std: : 线程池?这个问题有着松散的联系。尽管这个问题不同,但意图是一样的:

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

另一个问题得出的结论是,不能依赖 std::thread进行汇集(可能是,也可能不是)。然而,std::async(launch::async)似乎有更高的机会被汇集。

它不认为它是被标准强制的,但是恕我直言,如果线程创建缓慢,那么所有好的 C + + 11实现都会使用线程池。只有在创建新线程成本较低的平台上,我认为它们总是会产生新线程。

问题2: 这只是我的想法,但我没有事实可以证明。我可能搞错了。这是有根据的猜测吗?

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

例子一:

 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(); });

问题3: 与 thread版本相比,您更喜欢 async版本吗?


剩下的不再是问题的一部分,而只是为了澄清:

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

不幸的是,当前的 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
}

另一项澄清是:

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

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

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

  • 使用 std::thread创建一个新线程不需要初始化线程本地变量。
  • 在由 async产生的线程中,对我来说有些不清楚,因为线程可能已经被重用了。根据我的理解,线程局部变量不一定会被重置,但是我可能弄错了。
  • 另一方面,使用自己的(固定大小的)线程池,可以在真正需要时给予完全控制权。
50755 次浏览

问题1 :

我把原版改了,因为原版错了。在我的印象中,Linux 线程的创建非常便宜和测试之后,我确定在一个新线程中调用函数的开销比在一个普通线程中调用函数的开销是巨大的。创建用于处理函数调用的线程的开销大约是普通函数调用的10000倍或更多倍。因此,如果要发出大量的小函数调用,线程池可能是一个好主意。

很明显,附带 g + + 的标准 C + + 库没有线程池。但我绝对能为他们立案。即使需要将调用推送到某种线程间队列,这也可能比启动一个新线程更便宜。标准允许这样。

恕我直言,Linux 内核开发人员应该努力降低线程创建的成本。但是,标准的 C + + 库也应该考虑使用池来实现 launch::async | launch::deferred

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

问题2 :

是的,基本上这个“隐式”启动了一个线程。但事实上,发生了什么还是很明显的。所以我不认为含蓄这个词是一个特别好的词。

我也不相信强迫你等到回归才毁灭一定是个错误。我不知道您是否应该使用 async调用来创建不期望返回的“守护程序”线程。如果期望他们返回,忽视异常是不对的。

问题3 :

就个人而言,我喜欢线程启动是明确的。我很看重岛屿,在那里你可以保证串行访问。否则,您最终将处于易变状态,您必须始终在某个地方包装互斥对象并记住使用它。

我更喜欢工作队列模型,而不是“未来”模型,因为这里有“串行岛”,所以可以更有效地处理可变状态。

但实际上,这取决于你到底在做什么。

性能测试

因此,我测试了各种调用方法的性能,并在运行 Fedora 29的8核(AMD Ryzen 72700X)系统上得出了这些数字,该系统使用 clang version 7.0.1和 libc + + (而不是 libstdc + +)编译:

   Do nothing calls per second:   35365257
Empty calls per second:   35210682
New thread calls per second:      62356
Async launch calls per second:      68869
Worker thread calls per second:     970415

而且,在我的 MacBook Pro 15“(Intel (R) Core (TM) i7-7820HQ CPU@2.90 GHz)和 OSX 10.13.6下的 Apple LLVM version 10.0.0 (clang-1000.10.44.4)上,我得到了这个:

   Do nothing calls per second:   22078079
Empty calls per second:   21847547
New thread calls per second:      43326
Async launch calls per second:      58684
Worker thread calls per second:    2053775

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

“什么也不做”只是为了测试测试装具的开销。

很明显,启动一个线程的开销是巨大的。即使是带有线程间队列的工作线程,在 VM 中的 Fedora 25上也会将速度降低20倍左右,在本地 OS X 上则会降低8倍左右。

我创建了一个 OSDN 室,里面保存着我用于性能测试的代码