（原创）用C++11的std::async代替线程的创建

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

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_status）来获取异步操作的结果。future_status有三种状态：

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

//查询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，其中get等待异步操作结束并返回结果，wait只是等待异步操作完成，没有返回值，wait_for是超时等待返回结果。

std::promise

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

    std::promise<int> pr;
    std::thread t([](std::promise<int>& p){ p.set_value_at_thread_exit(9); },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又是干啥的，已经有了td::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 boost技术交流群：296561497，欢迎大家来交流技术。

一点梦想：尽自己一份力，让c++的世界变得更美好！

分类: C++ , c++11 使用c++11改进我们的程序系列

Effective Modern C++ 条款36 如果异步执行是必需的，指定std::launch::async策略

如果异步执行是必需的，指定std::launch::async策略

当你调用std::async来执行一个函数（或一个可执行对象）时，你通常希望函数是异步执行的。但你没有要求std::async必须这样做，函数是根据std::async的发射策略（launch policy）来执行的。有两个标准策略，每个都是通过std::launch局部枚举（scoped enum，看条款10）来表示。假设一个函数f要传递给std::launch执行，

std::launch::async发射策略意味着函数f必须异步执行，即在另一线程执行。
std::launch::deferred发射策略意味着函数f可能只会在——std::async返回的future对象调用get或wait时——执行。那就是，执行会推迟到其中一个调用发生。当调用get或wait时，f会同步执行，即，调用者会阻塞直到f运行结束。如果get或wait没有被调用，f就绝对不会执行。

可能很奇怪，std::async的默认发射策略——它的默认策略是你不能显式指定的——不是两者其中的一种，相反，是两者进行或运算。下面两个函数完全是相同的意思：

auto fut1 = std::async(f);       // 使用默认发射策略执行f

auto fut2 = std::async(std::launch::async |     // 使用async或deferred执行f
                       std::launch::deferred
                       f);

默认的发射策略允许异步或同步执行函数f，就如条款35指出，这个灵活性让std::async与标准库的线程管理组件一起承担线程创建和销毁、避免过载、负责均衡的责任。这让用std::async进行并发编程变得很方便。

但用std::async的默认发射策略会有一些有趣的含义。这语句给定一个线程t执行f，

auto fut = std::async(f);        // 使用默认发射模式执行f

没有办法预知函数f是否会和线程t并发执行，因为f可能会被调度为推迟执行。
没有办法预知函数f是否运行在——与调用get或wait函数的线程不同的——线程。如果那个线程是t，这句话的含义是没有办法预知f是否会运行在与t不同的线程。
可能没有办法预知函数f是否执行完全，因为没有办法保证fut会调用get或wait。

默认发射策略的调度灵活性经常会混淆使用thread_local变量，这意味着如果f写或读这种线程本地存储(Thread Local Storage，TLS)，预知取到哪个线程的本地变量是不可能的：

auto fut = std::async(f);         // f使用的线程本地存储变量可能是独立的线程的，
                                  // 也可能是fut调用get或wait的线程的

它也影响了基于wait循环中的超时情况，因为对一个推迟（策略为deferred）的任务（看条款35）调用wait_for或者wait_until会返回值std::launch::deferred。这意味着下面的循环，看起来最终会停止，但是，实际上可能会一直运行：

using namespace std::literals;         // 对于C++14的持续时间后缀，请看条款34

void f()           // f睡眠1秒后返回
{
    std::this_thread::sleep_for(1s);
}

auto fut = std::async(f);          // （概念上）异步执行f

while(fut.wait_for(100ms) !=         // 循环直到f执行结束
      std::future_status::ready)     // 但这可能永远不会发生
{
    ...
}

如果f与调用std::async的线程并发执行（即，使用std::launch::async发射策略），这里就没有问题（假设f能结束执行，不会一直死循环）。但如果f被推迟（deferred），fut.wait_for将总是返回std::future_status::deferred。那永远也不会等于std::future_status::ready，所以循环永远不会终止。

这种bug在开发或单元测试中很容易被忽略，因为它只会在机器负载很重时才会显现。在机器过载（oversubscription）或线程消耗完的状况下，任务很可能会被推迟（如果使用的是默认发射策略）。总之，如果不是过载或者线程耗尽，运行系统没有理由不调度任务并发执行。

解决办法很简单：检查std::async返回的future，看它是否把任务推迟，然后呢，如果真的是那样，就避免进入基于超时的循环。不幸的是，没有办法直接询问future的任务是否被推迟。取而代之的是，你必须调用一个基于超时的函数——例如wait_for函数。在这种情况下，你不用等待任何事情，你只是要看看返回值是否为std::future_status::deferred，所以请相信这迂回的话语和用0来调用wait_for：

auto fut = std::async(f);       // 如前

if (fut.wait_for(0) == std::future_status::deferred)  // 如果任务被推迟
{
    ...     // fut使用get或wait来同步调用f
} else {            // 任务没有被推迟
    while(fut.wait_for(100ms) != 
         std::future_status::ready) {       // 不可能无限循环（假定f会结束）

      ...    // 任务没有被推迟也没有就绪，所以做一些并发的事情直到任务就绪
    }

    ...        // fut就绪
}

考虑多种因素的结论是，只要满足了下面的条件，以默认发射策略对任务使用std::async能正常工作：

任务不需要与调用get或wait的线程并发执行。
修改哪个线程的thread_local变量都没关系。
要么保证std::async返回的future会调用get或wait，要么你能接受任务可能永远都不执行。
使用wait_for或wait_unitil的代码要考虑到任务推迟的可能性。

如果其中一个条件没有满足，你很可能是想要确保任务能异步执行。而那样做的方法是，当你调用std::async时，把std::launch::async作为第一个参数传递给它：

auto fut = std::async(std::launch::async, f);    // 异步发射f

事实上，如果有一个函数的行为像std::async那样，但它会自动使用std::launch::async作为发射策略，那样就是一个方便的工作啦！它很容易写出来，棒极了。这是C++11的版本：

template<typename F, typename... Ts>
inline
std::future<typename std::result_of<F(Ts...)>::type>
reallyAsync(F&& f, Ts&&... params)     // 返回异步调用f(param...)的future
{
    return std::async(std::launch::async,
                      std::forward<F>(f),
                      std::forward<Ts>(params)...);
}

这个函数接收一个可调用对象f和零个或多个参数params，并且把它们完美转发（看条款25）给std::async，传递std::launch::async作为发射策略。就像std::async那样，它返回一个类型为f调用params的结果的std::future，决定这个结果很容易，因为std::result_of这个type trait可以把结果给你。

reallyAsync用起来就像std::async那样：

auto fut = reallyAsync(f);    // 异步执行f，如果std::async抛异常reallyAsync也会抛异常

在C++14中，推断reallyAsync返回值类型的能力简化了函数声明：

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

这个版本很清楚地让你知道reallyAsync除了使用std::launch::async发射策略调用std::async外，没做任何东西。