C++11 基础之多线程二

四、future和promise

    C++11创建了线程之后，我们不能直接从thread.joid()获取结果，C++11提供了future来获取异步操作的结果。这个结果是不能立即获取的，会在未来的某个时间内进行获取。而future和和promise的作用就是在线程之间传递数据。

#include <future>

void test_pro(promise<string> &p){
    this_thread::sleep_for(chrono::milliseconds(2000));
    //传值
    p.set_value("hello, this is my value");
}
void test_future(){

    promise<string> pro;

    thread t1(test_pro, ref(pro));
    cout << "thread1 is running;" << endl;
    //promise和future进行绑定
    future<string> f = pro.get_future();
    //从future中获取值，在p.set_value()之后就可以获取值了
    //在p.set_value()之前，线程会一直阻塞在此处
    auto res = f.get();

    cout << "res : " << res << endl;
}

    此处获取异步操作结果使用的是get，当然还有wait以及wait_for。

wait_for：

    函数原型：

template< class Rep, class Period > 
std::future_status wait_for( const std::chrono::duration<Rep,Period>& timeout_duration ) const;

    阻塞至结果变得可用，或者阻塞至经过指定的timeout_duration，返回值鉴别结果的状态。

    参数timeout_duration是阻塞的最大时长。

    返回结果有三种状态：

• future_status::deferred：要计算结果的函数未启动
• future_status::ready：结果准备就绪
• future_status::timeout：超时

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

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

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

五、future和package_task

    package_task包装了一个可调用对象，允许异步获取该可调用对象产生的结果。package_task将其包装的可调用对象的执行结果传递给一个future对象。

    C++中可调用对象：函数、函数指针、lambda表达式、重载了函数调用运算符的函数对象类以及bind创建的对象。

int addOne(int x){
    return x + 1;
}

void test_package_task(){
    packaged_task<int(int)> pt1(addOne);
    future<int> fu1 = pt1.get_future();

    //声明一个变量
    int c = 0;

    //创建一个线程t1，将pt1及对应的参数放到线程里面执行
    std::thread t1(std::move(pt1), c);

    //阻塞至线程t1结束(函数addOne返回结果)
    int iResult = fu1.get();

    std::cout << "执行结果：" << iResult << std::endl;	//执行结果：1
    std::cout << "c：" << c << std::endl;	//c：0
}

六、线程异步操作函数async

    async可以创建异步任务，并且将其运行结果保存在future中，我们可以在外面从future中取值。

    async原型：async(std::launch::async | std::launch::deferred, f, args...)

   第一个参数是线程创建策略：

• std::launch::async：在调用async的时候就创建线程
• std::launch::deferred：延迟加载的方式创建线程。即调用async的时候不创建线程，在调用future的get或wait的时候才创建线程

    第二个参数是线程要执行的函数，之后的参数是往线程执行函数中传递的参数。

void test_async(){
    //策略1
    std::future<int> fut = std::async(std::launch::async, []() {
        cout<<" 开始执行async" << endl;
        return 1;
    });

    //策略2
    std::future<int> fut2 = std::async(std::launch::deferred, []() {
        cout<<" 开始执行deferred" << endl;

        return 2;
    });

    std::cout << "result:" << fut.get() << std::endl;
    this_thread::sleep_for(chrono::milliseconds(2000));
    std::cout << "result:" << fut2.get() << std::endl;
}