浅谈C++异步

头文件 #include<future> ，在Linux下需要添加 -lpthread 参数

std::async

本质上是创建一个线程，使用传递的任务方法在线程中运行， 通过std::launch::async/deferred 来设置是否立即调用还是延迟调用

std::future

获得任务结果, 使用future的get方法，获得任务执行的返回值， 但是如果当前任务尚未执行， 任务会触发立即执行， 并且堵塞当前线程，直到任务完成

方法

• get() //获取任务返回结果，该方法只能调用一次, 使用后futrue变得不确定
• wait() //等待任务完成
• wait_for(dur) //等待一定时间或运行完成
• wait_until(fp) //等待某一时刻或运行完成
• share() //生成一个shared_future，shared_futrue类型允许使用第二次， 并且使用获得结果与第一次一样，如果有一场，抛出的异常也是一样的。

* 范例1

#include <iostream>
#include <future>

int main(int argc, char* args[])
{

    //创建完成后线程实际上已经开始运行
    std::future<int> ret = std::async([](){
        std::cout << "Task Thread ID:" << std::this_thread::get_id() << std::endl;
        //假设这里是一个很费时间的一个操作
        return 0;
    });

    std::cout << "Main Thread ID:" << std::this_thread::get_id() << std::endl;

    //如果当前任务未完成的话，主线程会堵塞，当然我们也可以把堵塞的任务传递给其他线程做
    std::cout << "Ret:" << ret.get() << std::endl;

    return  0;
}

* 范例2

多线程下的使用

#include <iostream>
#include <future>

//任务方法
void task(std::promise<int> &prom)
{
    int ret;
    //假设这里是一个很费时间的一个操作
    ret = 4;

    prom.set_value_at_thread_exit(ret);
}

//打印任务结果
void printRet(std::future<int> &future)
{
    std::cout << "ret:" << future.get() << std::endl;
}

int main(int argc, char* args[])
{
    std::promise<int> prom;
    std::future<int> future = prom.get_future();

    //创建线程执行任务
    std::thread t = std::thread(task, std::ref(prom));
    //创建线程接受任务执行结果
    std::thread t2 = std::thread(printRet, std::ref(future));

    //等待线程完成
    t.join();
    t2.join();

    return  0;
}

* 范例3

参数传递

#include <iostream>
#include <future>

int sum(int a, int b)
{
    return  a + b;
}

int main(int argc, char* args[])
{

    //创建完成后线程实际上已经开始运行，参数附加在末尾
    std::future<int> ret = std::async(sum, 1, 2);

    std::cout << "Main Thread ID:" << std::this_thread::get_id() << std::endl;

    //如果当前任务未完成的话，主线程会堵塞，当然我们也可以把堵塞的任务传递给其他线程做
    std::cout << "Ret:" << ret.get() << std::endl;

    return  0;
}

std::shared_future

使用与futrue相似。，shared_futrue类型允许使用第二次， 并且使用获得结果与第一次一样，如果有一场，抛出的异常也是一样的
std::shared_futrue f = std::async(task).share();

std::packaged_task（重点）

将任务打包， 好处是，可以手动触发何时执行任务

#include <iostream>
#include <future>

int sum(int a, int b)
{
    std::cout << "Task Thread ID:" << std::this_thread::get_id() << std::endl;
    return  a + b;
}

int main(int argc, char* args[])
{
    //对任务进行封装
    std::packaged_task<int(int, int)> task(sum);
    //获取future
    std::future<int> future = task.get_future();

    //直接出发任务task(1, 2),但是任务处于调用线程中
    //移动到线程中执行异步任务
    std::thread t = std::thread(std::move(task), 1, 3);

    std::cout << "Main Thread ID:" << std::this_thread::get_id() << std::endl;

    std::cout << "Ret:" << future.get() << std::endl;
    t.join();
    return 0;
}

范例 4

使用wait_for 等待任务完成

#include <iostream>
#include <future>

double recursive(double a)
{
    std::this_thread::sleep_for(std::chrono::milliseconds(10));
    if ( a == 0)
    {
        return a;
    }

    return  recursive(a - 1) + a;
}

int main()
{
    std::packaged_task<double(double)> task(recursive);
    std::future<double> future = task.get_future();


    //移动到线程中处理
    std::thread t = std::thread(std::move(task), 1000);
    std::thread t2 = std::thread([](std::future<double>& future){
        //等待线程完成执行
        while (future.wait_for(std::chrono::milliseconds(200)) == std::future_status::timeout)
        {
            std::cout << ".";
        }
        std::cout << "\n" << std::endl;

        std::cout << "result:" << future.get() << std::endl;
    }, std::ref(future));

    t.join();
    t2.join();

    return 0;
}

范例 5

futrue共享状态在get调用后就解除，下次调用会发生报错。 但是使用shared_future的时候，get方法可调用多次，但是结果是一样的

#include <iostream>
#include <future>

int do_work()
{
    return 100;
}

int main()
{
    std::future<int> future = std::async(do_work);
    //获取共享future
    std::shared_future<int> shared_future = future.share();

    //shared_future多次获取结果
    std::cout << "ret1:" << shared_future.get() << std::endl;
    std::cout << "ret2:" << shared_future.get() << std::endl;
    return 0;
}