C++11 std::future, std::promise, std::packaged_task, 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 pr;
std::thread t([](std::promise& p){ p.set_value_at_thread_exit(9); },std::ref(pr));
std::future 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 task([](){ return 7; });
std::thread t1(std::ref(task));
std::future f1 = task.get_future();
auto r1 = f1.get();

std::promise、std::packaged_task和std::future的关系
在线程1中创建一个std::promise对象

std::promise promiseObj;
目前为止,该promise对象没有任何管理的值,但它承诺肯定会有人对其进行赋值,一旦被赋值,就可以通过其管理的std::future对象来获取该值。
但是,假设线程1创建了该promise对象并将其传给线程2,那么线程1怎样知道线程2什么时候会对promise对象进行赋值呢?
答案是使用std::future对象
每个std::promise对象都有个对应的std::future对象,其他人可以通过它来获取promise设置的值。
所以,线程1将会创建std::promise对象,然后在将其传递给线程2之前从它那里获取std::future对象。

std::future futureObj = promiseObj.get_future();
现在,线程1将promiseObj传递给线程2.
那么线程1将会获取到线程2通过std::future的get函数设置在std::promise中的值,

int val = futureObj.get();
但是如果线程2还没有对该值进行设置,那么这个调用将会阻塞,直到线程2在promise对象中对该值进行设置。

promiseObj.set_value(45);
查看下图中的完整流程


C++11 std::future, std::promise, std::packaged_task, std::async_第1张图片
image.png

至此, 我们介绍了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的差异。
示例1:

#include 
#include 
#include  

void Thread_Fun1(std::promise &p)
{    
    //为了突出效果,可以使线程休眠5s
    std::this_thread::sleep_for(std::chrono::seconds(5));
    
    int iVal = 233;
    std::cout << "传入数据(int):" << iVal << std::endl;
    
    //传入数据iVal    
    p.set_value(iVal);
} 

void Thread_Fun2(std::future &f){
    //阻塞函数,直到收到相关联的std::promise对象传入的数据
    auto iVal = f.get();    //iVal = 233
    
    std::cout << "收到数据(int):" << iVal << std::endl;
} 

int main(){    
    //声明一个std::promise对象pr1,其保存的值类型为int
    std::promise pr1;    
    //声明一个std::future对象fu1,并通过std::promise的get_future()函数与pr1绑定
    std::future fu1 = pr1.get_future();
    //创建一个线程t1,将函数Thread_Fun1及对象pr1放在线程里面执行
    std::thread t1(Thread_Fun1, std::ref(pr1));

    //创建一个线程t2,将函数Thread_Fun2及对象fu1放在线程里面执行
    std::thread t2(Thread_Fun2, std::ref(fu1));     //阻塞至线程结束

    t1.join();
    t2.join();

    return 1;
}

可以看到std::future对象fu1先是通过std::promise的函数get_future()与std::promise对象pr1相绑定,pr1在线程t1中通过set_value()传入共享数据,fu1在线程t2中通过阻塞函数get()获取到传入的数据。
示例1中传入的数据类型是int,前面介绍中说std::promise可以保存typename T的数据,那么可以保存函数指针吗?答案是可行的,请看示例。

示例2:

#include 
#include 
#include 
#include  

//声明一个可调对象Tusing 
T = std::function;    //等同于typedef std::function T; 

int Test_Fun(int iVal)
{
    std::cout << "Value is:" << iVal << std::endl;
    return iVal + 232;
} 

void Thread_Fun1(std::promise &p)
{    
    //为了突出效果,可以使线程休眠5s
    std::this_thread::sleep_for(std::chrono::seconds(5));

    std::cout << "传入函数Test_Fun" << std::endl;

    //传入函数Test_Fun
    p.set_value(std::bind(&Test_Fun, std::placeholders::_1));
} 

void Thread_Fun2(std::future &f)
{    
    //阻塞函数,直到收到相关联的std::promise对象传入的数据
    auto fun = f.get();        //iVal = 233

    int iVal = fun(1);

    std::cout << "收到函数并运行,结果:" << iVal << std::endl;
} 

int main()
{
    //声明一个std::promise对象pr1,其保存的值类型为int
    std::promise pr1;    
    //声明一个std::future对象fu1,并通过std::promise的get_future()函数与pr1绑定
    std::future fu1 = pr1.get_future();

    //创建一个线程t1,将函数Thread_Fun1及对象pr1放在线程里面执行
    std::thread t1(Thread_Fun1, std::ref(pr1));    
    
    //创建一个线程t2,将函数Thread_Fun2及对象fu1放在线程里面执行
    std::thread t2(Thread_Fun2, std::ref(fu1));

    //阻塞至线程结束
    t1.join();
    t2.join();
    return 1;
}

既然可以传函数对象,那么是否可以通过模板魔改,传入可变元函数?请看示例。

示例3:

#include 
#include 
#include 
#include  

//声明一个可调对象Fusing F = std::function;        //等同于typedef std::function F; 

//函数可以改成任意参数,任意返回类型int Test_Fun(int a, int b, int &c)
{
    //a = 1, b = 2    c = a + b + 230;
    return c;
}

void Thread_Fun1(std::promise &p)
{    
    //为了突出效果,可以使线程休眠5s
    std::this_thread::sleep_for(std::chrono::seconds(5));

    std::cout << "传入函数Test_Fun" << std::endl;

    //传入函数Test_Fun
    p.set_value(std::bind(&Test_Fun, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
} 

template
void Thread_Fun2(std::future &f, Args&& ...args)
{
    //阻塞函数,直到收到相关联的std::promise对象传入的数据
    auto fun = f.get();        //fun等同于Test_Fun
    
    auto fResult = fun(std::forward(args)...);

    std::cout << "收到函数并运行,结果:" << fResult << std::endl;
} 

int main()
{    

    //声明一个std::promise对象pr1,其保存的值类型为int
    std::promise pr1;
    //声明一个std::future对象fu1,并通过std::promise的get_future()函数与pr1绑定
    std::future fu1 = pr1.get_future();     
    
    //声明一个变量
    int iVal = 0;     
    
    //创建一个线程t1,将函数Thread_Fun1及对象pr1放在线程里面执行
    std::thread t1(Thread_Fun1, std::ref(pr1));
    //创建一个线程t2,将函数Thread_Fun2及对象fu1放在线程里面执行
    std::thread t2(Thread_Fun2, std::ref(fu1), 1, 2, std::ref(iVal));

    //阻塞至线程结束
    t1.join();
    t2.join();
    //此时iVal的值变成233

    return 1;
}

为什么要用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 f1 = std::async(std::launch::async, [](){
    return 8;
});

cout< f2 = std::async(std::launch::async, [](){
    cout<<8< 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之std::future和std::promise
[C++11]std::promise介绍及使用
(原创)用C++11的std::async代替线程的创建
c++11多线程编程(八):std::future , std::promise和线程的返回值

你可能感兴趣的:(C++11 std::future, std::promise, std::packaged_task, std::async)