c++11：std::async、std::launch_为什么执行 auto f = std::async(std::launch::async 没有立即返

1、std::async

template <class Fn, class... Args>
  future<typename result_of<Fn(Args...)>::type>
    async (Fn&& fn, Args&&... args);

template <class Fn, class... Args>
  future<typename result_of<Fn(Args...)>::type>
    async (launch policy, Fn&& fn, Args&&... args);

Call function asynchronously
Calls fn (with args as arguments) at some point, returning without waiting for the execution of fn to complete.

The value returned by fn can be accessed through the future object returned (by calling its member future::get).

The second version (2) lets the caller select a specific launching policy, while the first version (1) uses automatic selection, as if calling (2) with launch::async|launch::deferred as policy.

The function temporarily stores in the shared state either the threading handler used or decay copies of fn and args (as a deferred function) without making it ready. Once the execution of fn is completed, the shared state contains the value returned by fn and is made ready.

example:

// async example
#include <iostream>       // std::cout
#include <future>         // std::async, std::future
 
// a non-optimized way of checking for prime numbers:
bool is_prime (int x) {
  std::cout << "Calculating. Please, wait...\n";
  for (int i=2; i<x; ++i) if (x%i==0) return false;
  return true;
}
 
int main ()
{
  // call is_prime(313222313) asynchronously:
  std::future<bool> fut = std::async (is_prime,313222313);
 
  std::cout << "Checking whether 313222313 is prime.\n";
  // ...
 
  bool ret = fut.get();      // waits for is_prime to return
 
  if (ret) std::cout << "It is prime!\n";
  else std::cout << "It is not prime.\n";
 
  return 0;
}

output:

std::async开一个线程去执行is_prime()。默认不等待继续执行，std::future<bool>类型的fut接收返回值（用get()获取）

2、std::launch

A bitmask value of type launch indicating the launching policy:

example:

// launch::async vs launch::deferred
#include <iostream>     // std::cout
#include <future>       // std::async, std::future, std::launch
#include <chrono>       // std::chrono::milliseconds
#include <thread>       // std::this_thread::sleep_for
 
void print_ten (char c, int ms) {
  for (int i=0; i<10; ++i) {
    std::this_thread::sleep_for (std::chrono::milliseconds(ms));
    std::cout << c;
  }
}
 
int main ()
{
  std::cout << "with launch::async:\n";
  std::future<void> foo = std::async (std::launch::async,print_ten,'*',100);
  std::future<void> bar = std::async (std::launch::async,print_ten,'@',200);
  // async "get" (wait for foo and bar to be ready):
  foo.get();
  bar.get();
  std::cout << "\n\n";
 
  std::cout << "with launch::deferred:\n";
  foo = std::async (std::launch::deferred,print_ten,'*',100);
  bar = std::async (std::launch::deferred,print_ten,'@',200);
  // deferred "get" (perform the actual calls):
  foo.get();
  bar.get();
  std::cout << '\n';
 
  return 0;
}

output:

compare:

std::launch::deferred：那么线程的执行就会推迟到std::future.get()方法时才会启动,如果不使用get或者wait时，线程直到结束也不会去执行fn，还有一点是在get()之前彻底就没开辟新线程。

std::launch::async：声明的时候就会去创建新线程（系统默认使用的就是这个参数）。和无std::launch::async的std::async不一样的地方是无std::launch::async的std::async需要手动去get()去等待线程结束，而std::launch::async会自动阻塞等待完成。如果在不需要返回值的情况下使用std::launch::asynch会更方便。