C++11新特性--更方便的并发支持

标准库<future>

    C++11的标准库<future>主要包含了std::future，std::promise，std::packaged_task等类，它们的主要作用简言之通常是在工作线程提供计算并且将计算结果赋值给关心计算结果并且在其他线程等待的变量。这个库高度封装了并发相关的同步等问题，提供了一种简单的异步编程方式，使得一些简单的异步调用可以用及其简单的代码实现，而且一如既往，是完全跨平台的。
    通常来讲我们常用到的就是上面提到的三个类，其中std::future就是等待的角色，它去等待其他线程的计算执行完毕，并且获取执行所得的结果。std::promise是许诺一个std::future对象，它负责去给future对象关心的结果赋值，在promise没有赋值之前，future对象是阻塞的，知道promise对象赋值为止。std::packaged_task是将计算过程和promise合并包装的一个类，可以理解为它向外面提供一个future对象，在它完成计算后通过promise对象给future对象赋值。

std::future和std::promise

    上面描述了他们之间的关系，下面直接看一下代码，一目了然。

        std::promise<char> pro;
        std::future<char> fu = pro.get_future();

        std::thread thread_pro([&]() -> void
                            {
                                std::this_thread::sleep_for(std::chrono::seconds(2));
                                pro.set_value('c');
                            });
        char cret = fu.get(); //will block 2s

        std::cout << "promise value is:" << cret << "  get again: " << (fu.valid() ? fu.get() : 'n') << std::endl;

        thread_pro.detach();

    代码很简单，工作线程认为block2s，然后promise对象向future对象赋值，这时其他线程等待的future得到运行线程恢复。这里注意看一下一旦future对象get了对应的value，那么它的状态就是invalid的了，再去get就会异常，所以get之前应该判断一下是否valid。

std::packaged_task

    packaged_task封装的更进一步，将执行函数和函数返回值统一起来，再异步通知给等待的future对象，来看一下代码。

        int sum = 0;
        std::packaged_task<int(int, int)> packge_func([&](int a, int b) -> int
                                                 {
                                                     sum = a + b;
                                                     std::this_thread::sleep_for(std::chrono::seconds(2));
                                                     return sum;
                                                 });
        std::future<int> future = packge_func.get_future();
        std::thread thread_pack_func(std::move(packge_func), 3, 10);


        int ret = future.get();
        std::cout << "sum is:" << sum << "  ret is:" << ret << std::endl;
        thread_pack_func.detach();

    上面代码展示了packaged_task“打包了”一个函数调用，并将这个函数执行的结果返回给了调用线程，同样的，future对象会阻塞当前线程等待着执行结果的到来。
    如果结合std::bind使用，packaged_task就有了更强大的用处。比如前面文章中的线程池的实现，如果用packaged_task将传入函数和其参数一通打包，同样可以作为一个任务在线程池中运行，不同的是，外部线程可以用future对象直接获取到函数返回值，而不用通过回调函数的方式。下面看一下简单的例子

        int refa = 12;
        int refb = 12;
        std::packaged_task<int()> pack_bind(std::bind(
                [&](int &a, int &b) -> int
                {
                    std::this_thread::sleep_for(std::chrono::seconds(2));
                    int tempa = a;
                    int tempb = b;
                    a = 33;
                    b = 44;
                    return tempa * tempb;
                },
                std::ref<int>(refa),
                std::ref<int>(refb)
        ));
        std::future<int> future_bind = pack_bind.get_future();

        std::thread thread_pack_bind(std::move(pack_bind));

        std::cout << "result is:" << future_bind.get() << " a is: " << refa << " b is:" << refb << std::endl;
        thread_pack_bind.detach();

    上面代码将一个函数和它的两个参数绑定成为一个bind对象，再将这个bind对象打包，最终将这个package在线程中运行，等待线程直接获取到最初函数的返回值。这种高度绑定打包将会在某些特定场合让你的代码显得十分简洁而优雅。

最后

    在<future>库中还有一些类和函数实现，不过基本上都是为了上述的目的服务的，有兴趣可以查阅文档。这一篇中的并发编程，是对线程、锁、条件变量的封装应用，在特定场景下会简化很多代码，所以熟悉一下它们的使用十分必要。