Item 36: Specify std::launch::async if asynchronicity is essential.

当你使用 std::async() When executing a function or callable object,You usually expect this function to be executed asynchronously.但是, std::async() Not necessarily as you wish.其实 std::async() It is based on the execution strategy to decide whether to execute asynchronously. std::async() There are two execution strategies,定义在 std::launch 作用域中：

• std::launch::async The function or executable object must execute asynchronously,That is, running on other threads.
• std::launch::deferred The function or executable object is executed lazily.仅在 std::async() 的返回对象 std::future 调用 get 或 wait 时,It is executed synchronously in the current thread,And the caller blocks until the function execution completes.

std::async() The default strategy is actually a combination of the two,That is, the following two have the same meaning：

auto fut1 = std::async(f); // run f using default launch policy

auto fut2 = std::async(std::launch::async |   // run f either
                       std::launch::deferred, // async or
                       f);                    // deferred

under the default policy,f It may be executed synchronously or asynchronously.正如 Item 35: Prefer task-based programming to thread-based. 中讨论的：The thread management module of the standard library is responsible for the creation and release of threads,Oversubscription can be effectively avoided、保证负载均衡.This is extremely convenient std::async 的使用.

但是,The default strategy also has the following problems：

• 无法预测 f Whether to execute concurrently.
• 无法预测 f 是否运行在 get 或 wait on the thread at the time of the call.
• Not even predictable f 是否已经执行了.Because there is no guarantee that it will be called get 或 wait.

当 f To access thread-local storage（TLS,Thread Local Storage）时,It is impossible to predict which thread's local storage is being accessed.

auto fut = std::async(f); // TLS for f possibly for
                          // independent thread, but
                          // possibly for thread
                          // invoking get or wait on fut

std::async The default policy of wait_for Timeout call writing,可能导致 bug,例如：

using namespace std::literals; // for C++14 duration suffixes; see Item 34
void f()                       // f sleeps for 1 second, then returns
{
    
  std::this_thread::sleep_for(1s);
}
auto fut = std::async(f);             // run f asynchronously (conceptually)
while (fut.wait_for(100ms) !=         // loop until f has
       std::future_status::ready)     // finished running...
{
                                         // which may never happen!
  …
}

如果 std::async 是并发执行,That is, the execution strategy is std::launch::async,以上代码没有问题.但是,如果执行策略为 std::launch::deferred时,fut.wait_for 总是返回 future_status::deferred,There is a problem with the above code.解决办法也很简单,先通过 wait_for 的超时时间为 0 来检测 std::async 是异步执行还是同步执行：

auto fut = std::async(f);          // as above
if (fut.wait_for(0s) ==            // if task is
    std::future_status::deferred)  // deferred...
{
    
             // ...use wait or get on fut
  …          // to call f synchronously
  
} else {
         // task isn't deferred
  while (fut.wait_for(100ms) !=          // infinite loop not
         std::future_status::ready) {
        // possible (assuming
                                         // f finishes)
    …                // task is neither deferred nor ready,
                     // so do concurrent work until it's ready
  }
  …                  // fut is ready
}

综上,If your usage scenario is not the following,Then you need to consider whether you need to replace it std::async 的默认策略：

• 当调用 get 或 wait 时,Tasks do not need to be executed concurrently.
• It doesn't care which thread's local storage is being accessed.
• 可以保证 get 或 wait 一定会被调用,Or it is acceptable for the task not to be executed.
• 使用 wait_for 或 wait_until 时,需要考虑 std::launch::deferred 策略.

If not the above scenario,You may need to specify use std::launch::async 策略,That is, a thread is actually created to execute tasks concurrently：

auto fut = std::async(std::launch::async, f);  // launch f asynchronously

This provides a wrapper for concurrently executing tasks：

template<typename F, typename... Ts>  // C++11
inline
std::future<typename std::result_of<F(Ts...)>::type>
reallyAsync(F&& f, Ts&&... params)       // return future
{
                                            // for asynchronous
  return std::async(std::launch::async,  // call to f(params...)
                    std::forward<F>(f),
                    std::forward<Ts>(params)...);
}

reallyAsync Accepts an executable object f 和 多个参数 params,and perfectly forwarded to std::async ,同时使用 std::launch::async 策略.C++14 版本如下：

template<typename F, typename... Ts>
inline
auto     // C++14
reallyAsync(F&& f, Ts&&... params)
{
    
  return std::async(std::launch::async,
  std::forward<F>(f),
  std::forward<Ts>(params)...);
}

至此,本文结束.

参考：

• Effective Modern C++