我对文章的格式和错别字进行了调整，并补充并标注出了重要的部分。以下是正文。

正文

C++11 中增加了 std::thread，使得我们可以非常方便的创建线程，它的基本用法是这样的：

void f(int n);
std::thread t(f, n + 1);
t.join();

但是线程毕竟是属于比较低层次的东西，有时候使用有些不便，比如我希望获取线程函数的返回结果的时候，我就不能直接通过 thread.join() 得到结果，这时就必须定义一个变量，在线程函数中去给这个变量赋值，然后 join，最后得到结果，这个过程是比较繁琐的。

C++11 还提供了异步接口std::async，通过这个异步接口可以很方便的获取线程函数的执行结果。std::async 会自动创建一个线程去调用线程函数，它返回一个 std::future，这个 future 中存储了线程函数返回的结果，当我们需要线程函数的结果时，直接从 future 中获取，非常方便。

但是我想说的是，其实 std::async 给我们提供的便利可不仅仅是这一点 —— 它首先解耦了线程的创建和执行，使得我们可以在需要的时候获取异步操作的结果；其次它还提供了线程的创建策略（比如可以通过延迟加载的方式去创建线程），使得我们可以以多种方式去创建线程。

在介绍 async 具体用法以及为什么要用 std::async 代替线程的创建之前，我想先说一说 std::future、std::promise 和 std::packaged_task 。

std::future

std::future 是一个非常有用也很有意思的东西，简单说 std::future 提供了一种访问异步操作结果的机制。从字面意思来理解，它表示未来【我插一句， future 在经济上也有期货的意思，不是马上能变现的】，我觉得这个名字非常贴切，因为一个异步操作我们是不可能马上就获取操作结果的，只能在未来某个时候获取，但是我们可以以同步等待的方式来获取结果，可以通过查询 future 的状态（future_status）来获取异步操作的结果。

future_status 有三种状态

deferred：异步操作还没开始
ready：异步操作已经完成
timeout：异步操作超时

/// @note 查询 future 的状态
std::future_status status;
do
{
    status = future.wait_for(std::chrono::seconds(1));
    if (status == std::future_status::deferred)
    {
        std::cout << "deferred\n";
    }
    else if (status == std::future_status::timeout)
    {
        std::cout << "timeout\n";
    }
    else if (status == std::future_status::ready)
    {
        std::cout << "ready!\n";
    }
} while (status != std::future_status::ready);

获取 future 结果有三种方式

get：等待异步操作结束并返回结果；
wait：只是等待异步操作完成，没有返回值；
wait_for：是超时等待返回结果。

std::promise

std::promise 为获取线程函数中的某个值提供便利，在线程函数中给外面传进来的 promise 赋值，当线程函数执行完成之后就可以通过 promise 获取该值了，值得注意的是取值是间接的通过 promise 内部提供的 future 来获取的。它的基本用法：

std::promise<int> pr;
std::thread t([](std::promise<int> &p)
              { p.set_value_at_thread_exit(9); },
              std::ref(pr)); ///< std::ref 用于取 pr 的引用，显式进行传参，否则形参的引用是无效的
std::future<int> f = pr.get_future();
auto r = f.get();

std::packaged_task

std::packaged_task 它包装了一个可调用的目标（如 function, lambda expression, bind expression, or another function object）, 以便异步调用，它和 promise 在某种程度上有点像，promise 保存了一个共享状态的值，而 packaged_task 保存的是一个函数。它的基本用法：

std::packaged_task<int()> task([]()
                               { return 7; });
std::thread t1(std::ref(task));
std::future<int> f1 = task.get_future();
auto r1 = f1.get();

std::promise、std::packaged_task 和 std::future 的关系

至此, 我们介绍了 std::async 相关的几个对象 std::future、std::promise 和 std::packaged_task ，其中 std::promise 和 std::packaged_task 的结果最终都是通过其内部的 future 返回出来的，不知道读者有没有搞糊涂，为什么有这么多东西出来，他们之间的关系到底是怎样的？ 且听我慢慢道来:

std::future 提供了一个访问异步操作结果的机制，它和线程是一个级别的属于低层次的对象，在它之上高一层的是 std::packaged_task 和 std::promise，它们内部都有 future 以便访问异步操作结果，std::packaged_task 包装的是一个异步操作，而 std::promise 包装的是一个值，都是为了方便异步操作的，因为有时我需要获取线程中的某个值，这时就用 std::promise ，而有时我需要获取一个异步操作的返回值，这时就用 std::packaged_task 。那 std::promise 和 std::packaged_task 之间又是什么关系呢？说它们没关系也没关系，说它们有关系也有关系，都取决于你了，因为我可以将一个异步操作的结果保存到std::promise 中。

如果读者还没搞清楚它们的关系的话，我就用更通俗的话来解释一下。比如，一个小伙子给一个姑娘表白真心的时候也许会说：“我许诺会给你一个美好的未来” 或者 “我会努力奋斗为你创造一个美好的未来”。姑娘往往会说：“我等着”。现在我来将这三句话用 C++11 来翻译一下：

小伙子说：我许诺会给你一个美好的未来等于 C++11 中 std::promise a std::future;
小伙子说：我会努力奋斗为你创造一个美好的未来等于 C++11中 std::packaged_task a future;
姑娘说：我等着等于 C++11 中 future.get()/wait();

小伙子两句话的个中差异，自己琢磨一下，这点差异也是 std::promise 和 std::packaged_task 的差异。现实中的山盟海誓靠不靠得住我不知道，但是 C++11 中的许诺和未来是一定可靠的，发起来了许诺就一定有未来。细想起来 C++11 标准的制定者选定的关键字真是贴切而有意思！好了，插科打诨到此了，现在言归正传，回过头来说说 std::async。

std::async

为什么要用 std::async 代替线程的创建

std::async 又是干啥的，已经有了 std::future、std::promise 和std::packaged_task，够多的了，真的还要一个 std::async 来凑热闹吗，std::async 表示很委屈：我不是来凑热闹的，我是来帮忙的。是的，std::async 是为了让用户的少费点脑子的，它让这三个对象默契的工作。大概的工作过程是这样的：

std::async 先将异步操作用 std::packaged_task 包装起来，然后将异步操作的结果放到std::promise中，这个过程就是创造未来的过程。外面再通过future.get/wait 来获取这个未来的结果，怎么样，std::async 真的是来帮忙的吧，你不用再想到底该怎么用 std::future、std::promise 和std::packaged_task 了，std::async 已经帮你搞定一切了！

　　现在来看看 std::async 的原型 async(std::launch::async | std::launch::deferred, f, args...)

第一个参数是线程的创建策略，有两种策略，默认的策略是立即创建线程：

std::launch::async：在调用 async 就开始创建线程。
std::launch::deferred：延迟加载方式创建线程。调用 async 时不创建线程，直到调用了 future 的 get 或者 wait 时才创建线程。

第二个参数是线程函数， 第三个参数是线程函数的参数。

std::async 基本用法

std::future<int> f1 = std::async(std::launch::async, []()
                                 { return 8; });

cout << f1.get() << endl; //output: 8

std::future<int> f2 = std::async(std::launch::async, []()
                                 { cout << 8 << endl; });

f2.wait(); //output: 8

std::future<int> future = std::async(std::launch::async, []()
                                     {
                                         std::this_thread::sleep_for(std::chrono::seconds(3));
                                         return 8;
                                     });

std::cout << "waiting...\n";
std::future_status status;
do
{
    status = future.wait_for(std::chrono::seconds(1));
    if (status == std::future_status::deferred)
    {
        std::cout << "deferred\n";
    }
    else if (status == std::future_status::timeout)
    {
        std::cout << "timeout\n";
    }
    else if (status == std::future_status::ready)
    {
        std::cout << "ready!\n";
    }
} while (status != std::future_status::ready);

std::cout << "result is " << future.get() << '\n';

可能的结果：

waiting... timeout
timeout
ready! result is 8

总结

std::async 是更高层次上的异步操作，使我们不用关注线程创建内部细节，就能方便的获取异步执行状态和结果，还可以指定线程创建策略，应该用 std::async 替代线程的创建，让它成为我们做异步操作的首选。

【转载】一文搞定 C++11 的 std::promise、std::packaged_task、std::future、std::async

正文