[C++11 并发编程] 13 使用期望等待一次性事件

标签：c++   并发   async   future   

C++标准库使用期望（future）来支持一次性事件的等待。要等待某种一次性事件的线程可以获取一个代表该该事件的期望。这个线程可以每隔一段事件周期性的查询这个期望。此外，这个线程也可以继续做其它的处理，直到需要等待这个一次性事件才被挂起。通过期望还可以可以传递数据。

C++标准库提供了两种期望unique future（std::future<>）和shared futures（std::shared_future<>），都声明在<future>库头文件中。std::future实例只能关联到一个事件。而多个std::shared_future可以关联到同一个事件。共享期望所关联的事件发生时，所有期望实例都将同时被唤醒，而去访问这个事件。由于期望可以关联数据，所以期望都是模版类，没有数据关联到期望时，就可以使用std::future<void>和std::shared_future<void>。虽然期望被用于线程间通信，但是期望对象并不支持同步的访问，我们需要使用mutex之类的机制，来保护不同线程对它们的访问。

假设我们有一个需要较长时间的计算操作，我们要使用它的计算结果，在需要这个计算结果之前，我们可以做一些其它的操作。我们可以启动一个新的线程来做计算。std:;thread没有直接的机制来满足我们的需求。这里可以使用std::async函数模版来实现这个功能。

std::async可以启动一个异步的线程，我们无需像使用thread一样，立即开始等待这个异步线程执行结束，std::async会返回一个期望对象，这个对象最终会用来存储异步线程的返回结果。当我们需要这个结果时，对期望对象调用wait就可以让线程阻塞，直到期望准备好。例子如下：

#include <future>
#include <iostream>
int find_the_answer_to_ltuae()
{
    return 42;
}

void do_other_stuff()
{}

int main()
{
    std::future<int> the_answer=std::async(find_the_answer_to_ltuae);
    do_other_stuff();
    std::cout<<"The answer is "<<the_answer.get()<<std::endl;
}

#include <string>
#include <future>

struct X
{
    void foo(int,std::string const&);
    std::string bar(std::string const&);
};


X x;
// 调用x->foo(42, "hello");
auto f1=std::async(&X::foo,&x,42,"hello");
// 调用tmpx.bar("goodbye"); tmpx是x的拷贝
auto f2=std::async(&X::bar,x,"goodbye");

struct Y
{
    double operator()(double);
};
Y y;
// 调用tmpy(3.141)；tmpy是从Y()移动构造而来
auto f3=std::async(Y(),3.141);
// 调用y(2.718);
auto f4=std::async(std::ref(y),2.718);
X baz(X&);
// 调用baz(x);
auto f6=std::async(baz,std::ref(x));
class move_only
{
public:
    move_only();
    move_only(move_only&&);
    move_only(move_only const&) = delete;
    move_only& operator=(move_only&&);
    move_only& operator=(move_only const&) = delete;
    void operator()();
};
// 调用tmp();tmp是通过std::move(move_only)构造而来
auto f5=std::async(move_only());

• std::launch::deferred表示函数调用被推迟到期望的wait()或get()被调用时。
• std::launch::async表示启动新的线程来执行函数。
• std::launch::deferred | std::launch::async则表示通过具体实现来控制这个行为。

std::async模式使用第三种行为。

// 启动新的线程
auto f6=std::async(std::launch::async, Y(), 1.2);
// 在wait()或get()被调用时执行
auto f7=std::async(std::launch::deferred, baz, std::ref(x));
// 取决于实现
auto f8=std::async(std::launch::deferred | std::launch::async,
				   baz, std::ref(x));
auto f9=std::async(baz, std::ref(x));
// 调用被推迟的函数
f7.wait();

[C++11 并发编程] 13 使用期望等待一次性事件

标签：c++   并发   async   future   

原文地址：http://blog.csdn.net/yamingwu/article/details/48033709