std::futrue异步操作结果的三种搭配使用

目录

一、std::future

应用场景

二、使用 std::async关联异步任务

三、使用std::packaged_task和std::future配合

四、std::promise和std::future配合

一、std::future

应用场景

异步任务： 当我们需要在后台执⾏⼀些耗时操作时，如⽹络请求或计算密集型任务等，std::future 可以⽤来表⽰这些异步任务的结果。通过将任务与主线程分离，我们可以实现任务的并⾏处理，从⽽提⾼程序的执⾏效率

并发控制： 在多线程编程中，我们可能需要等待某些任务完成后才能继续执⾏其他操作。通过使⽤ std::future，我们可以实现线程之间的同步，确保任务完成后再获取结果并继续执⾏后续操作

结果获取：std::future提供了⼀种安全的⽅式来获取异步任务的结果。我们可以使⽤

std::future::get()函数来获取任务的结果，此函数会阻塞当前线程，直到异步操作完成。这样，在调⽤get()函数时，我们可以确保已经获取到了所需的结果

二、使用 std::async关联异步任务

 std::launch::deferred

#include <iostream>
#include <future>
#include <chrono>
int async_task(int a,int b)
{std::cout<<"加法"<<std::endl;return a+b;
}int main()
{//关联异步任务async_task和futurestd::cout<<"--------1--------"<<std::endl;//std::future<int> result_future=std::async(std::launch::async,async_task,1,2);  //函数会在⾃⼰创建的线程上运⾏std::future<int> result_future=std::async(std::launch::deferred,async_task,1,2);  //表明该函数会被延迟调⽤，直到在future上调⽤get()或者wait()才会开始//执⾏任务std::this_thread::sleep_for(std::chrono::seconds(1));// 此处可执⾏其他操作, ⽆需等待std::cout<<"--------2--------"<<std::endl;// 获取异步任务结果int result = result_future.get();std::cout<<"--------3--------"<<std::endl;std::cout << "Result: " << result << std::endl;return 0;
}

可以看到在 调⽤get()时才会执行

那如果参数是async呢

可以看到函数会在⾃⼰创建的线程上运⾏ 

三、使用std::packaged_task和std::future配合

#include <iostream>
#include <future>
#include <chrono>
int add(int num1, int num2)
{   std::cout<<"加法"<<std::endl;std::this_thread::sleep_for(std::chrono::seconds(3));return num1 + num2;
}
int main() {// 封装任务std::packaged_task<int(int, int)> task(add);// 此处可执⾏其他操作, ⽆需等待std::cout<<"--------1--------"<<std::endl;std::future<int> result_future = task.get_future();// 这⾥必须要让任务执⾏, 否则在get()获取future的值时会⼀直阻塞task(1,2);std::cout<<"--------2--------"<<std::endl;// 获取任务结果int result = result_future.get();std::cout << "Result: " << result << std::endl;return 0;
}

 运行可以看到

#include <iostream>
#include <future>
#include <chrono>
#include<memory>
int add(int num1, int num2)
{std::cout << "加法" << std::endl;std::this_thread::sleep_for(std::chrono::seconds(3));return num1 + num2;
}
int main()
{// 封装任务// std::packaged_task<int(int, int)> task(add);// // 此处可执⾏其他操作, ⽆需等待// std::cout << "--------1--------" << std::endl;// std::future<int> result_future = task.get_future();// 需要注意的是，task虽然重载了()运算符，但task并不是⼀个函数，//所以导致它作为线程的⼊⼝函数时，语法上看没有问题，但是实际编译的时候会报错//std::thread(task, 1, 2); //---错误⽤法//std::async(std::launch::async, task, 1, 2); //--错误⽤法//⽽packaged_task禁⽌了拷⻉构造，//且因为每个packaged_task所封装的函数签名都有可能不同，因此也⽆法当作参数⼀样传递//传引⽤不可取，毕竟任务在多线程下执⾏存在局部变量声明周期的问题，因此不能传引⽤//因此想要将⼀个packaged_task进⾏异步调⽤，//简单⽅法就只能是new packaged_task，封装函数传地址进⾏解引⽤调⽤了//⽽类型不同的问题，在使⽤的时候可以使⽤类型推导来解决std::cout << "--------1--------" << std::endl;auto task=std::make_shared<std::packaged_task<int(int,int)>>(add);std::future<int> fu=task->get_future();std::thread thr([task](){(*task)(1,2);});// 这⾥必须要让任务执⾏, 否则在get()获取future的值时会⼀直阻塞std::cout << "--------2--------" << std::endl;// 获取任务结果int result = fu.get();std::cout << "Result: " << result << std::endl;thr.join();return 0;
}

需要注意的是，task虽然重载了()运算符，但task并不是⼀个函数，

传引⽤（或指针）不可取，毕竟任务在多线程下执⾏存在局部变量声明周期的问题，因此不能传引⽤ ，因此想要将⼀个packaged_task进⾏异步调⽤，要在堆上创建空间，使用智能指针来进行管理。

四、std::promise和std::future配合

#include <iostream>
#include <future>
#include <chrono>//通过在线程中对promise进行赋值，其他线程来获取
void add(int num1, int num2,std::promise<int> &prom)
{prom.set_value(num1+num2);
}
int main()
{std::promise<int> prom;std::future<int> fu=prom.get_future();std::thread thr(add,1,2,std::ref(prom));int res=fu.get();  //同步关系 promise有值才能取std::cout<<"result: "<<res<<std::endl;thr.join();return 0;
}

这里就是同步关系 promise有值才能取