文章目录
一、std::future与std::async
1.基本概念
(1)std::future的基本知识
std::future期待一个返回,从一个异步调用的角度来说,future更像是执行函数的返回值,C++标准库使用std::future为一次性事件建模,如果一个事件需要等待特定的一次性事件,那么这线程可以获取一个future对象来代表这个事件。
异步调用往往不知道何时返回,但是如果异步调用的过程需要同步,或者说后一个异步调用需要使用前一个异步调用的结果。这个时候就要用到future。
线程可以周期性的在这个future上等待一小段时间,检查future是否已经ready,如果没有,该线程可以先去做另一个任务,一旦future就绪,该future就无法复位(无法再次使用这个future等待这个事件),所以future代表的是一次性事件。
(2)std::future的类型
在库的头文件中声明了两种future,唯一future(std::future)和共享future(std::shared_future)这两个是参照std::unique_ptr和std::shared_ptr设立的,前者的实例是仅有的一个指向其关联事件的实例,而后者可以有多个实例指向同一个关联事件,当事件就绪时,所有指向同一事件的std::shared_future实例会变成就绪。
std::future是一个模板,例如std::future,模板参数就是期待返回的类型,虽然future被用于线程间通信,但其本身却并不提供同步访问,热门必须通过互斥元或其他同步机制来保护访问。
(1)std::future的使用时机
future使用的时机是当你不需要立刻得到一个结果的时候,你可以开启一个线程帮你去做一项任务,并期待这个任务的返回,但是std::thread并没有提供这样的机制,这就需要用到std::async和std::future(都在头文件#include < future >中声明)std::async返回一个std::future对象,而不是给你一个确定的值(所以当你不需要立刻使用此值的时候才需要用到这个机制)。当你需要使用这个值的时候,对future使用get(),线程就会阻塞直到future就绪,然后返回该值。
2.代码演示
代码1:未使用std::future
#include<iostream>
#include<future>
int add(int a, int b) {
std::this_thread::sleep_for(std::chrono::seconds(5));//休眠五秒
return a + b;
}
void fun() {
std::cout << "this is fun()" << std::endl;
}
int main()
{
int c = add(1,2);//这行代码执行需要5秒,5秒后再向下执行
fun();
std::cout << c << std::endl;
return 0;
}
代码2:使用future
#include<iostream>
#include<future>
int add(int a, int b) {
std::this_thread::sleep_for(std::chrono::seconds(5));//休眠五秒
return a + b;
}
void fun() {
std::cout << "this is fun()" << std::endl;
}
int main() {
std::future<decltype(add(1, 2))> result = std::async(add, 1, 2);
//auto result = std::async(add, 1, 2); //OK 可以使用占位符auto进行类型推导
//std::future<int> result = std::async(add, 1, 2);//OK 由于知道函数的返回类型 所以可以直接确定模板类型int
//std::future<decltype(add, int, int)>result = std::async(add, 1, 2);//error
fun();
std::this_thread::sleep_for(std::chrono::seconds(5));//休眠5秒
std::cout << result.get() << std::endl;
return 0;
}
跟thread类似,async允许你通过将额外的参数添加到调用中,来将附加参数传递给函数。如果传入的函数指针是某个类的成员函数,则还需要将类对象指针传入(直接传入,传入指针,或者是std::ref封装)。
默认情况下,std::async是否启动一个新线程,或者在等待future时,任务是否同步运行都取决于你给的参数。这个参数为std::launch类型std::launch::defered表明该函数会被延迟调用,直到在future上调用get()或者wait()为止std::launch::async,表明函数会在自己创建的线程上运行
二、std::future与std::packaged_task
1.基本知识
如果说std::async和std::future还是分开看的关系的话,那么std::packaged_task就是将任务和future绑定在一起的模板,是一种封装对任务的封装。
可以通过std::packaged_task对象获取任务相关联的future,调用get_future()方法可以获得std::packaged_task对象绑定的函数的返回值类型的future。std::packaged_task的模板参数是函数签名。
例如int add(int a, intb)的函数签名就是int(int, int)
2.代码演示
由于和第一大点的差不多,这里简单代码演示
#include<iostream>
#include<future>
int add(int a, int b) {
std::this_thread::sleep_for(std::chrono::seconds(5));//休眠五秒
return a + b;
}
void fun() {
std::cout << "this is fun()" << std::endl;
}
int main() {
std::packaged_task<int(int, int)>task(add);//将函数和task绑定在一起了
std::future<int> result = task.get_future();
fun();
task(1, 2);//相当于执行函数 必须执行 否则的话 result.get()会一直阻塞 当我们执行这个task(1,2)的时候才算开始执行add函数 换句话说,当我们执行task(1,2)的时候,才会执行add函数里的5秒休眠
std::cout << result.get() << std::endl;
return 0;
}
三、std::future与std::promise
1.基本知识
从字面意思上理解promise代表一个承诺。promise比std::packaged_task抽象层次低。
std::promise提供了一种设置值的方式,它可以在这之后通过相关联的std::future对象进行读取。换种说法,之前已经说过std::future可以读取一个异步函数的返回值了,那么这个std::promise就提供一种方式手动让future就绪。
2.代码演示
#include <future>
#include <string>
#include <thread>
#include <iostream>
using namespace std;
void print(std::promise<std::string>& p)
{
this_thread::sleep_for(chrono::seconds(5));
p.set_value("There is the result whitch you want.");
}
void do_some_other_things()
{
std::cout << "Hello World" << std::endl;
}
int main()
{
std::promise<std::string> promise;
std::future<std::string> result = promise.get_future();
//thread的时候传入引用必须使用std::ref()函数
std::thread t(print, std::ref(promise));//开始执行print函数
do_some_other_things();//打印“hellowworld”
this_thread::sleep_for(chrono::seconds(5));
std::cout << result.get() << std::endl;//什么时候想要线程的返回值什么时候result.get()
t.join();
return 0;
}