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

目录

一、std::future

应用场景

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

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

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

---

一、std::future

        std::future是C++11标准库中的⼀个模板类，它表⽰⼀个异步操作的结果。当我们在多线程编程中使⽤异步任务时，std::future可以帮助我们在需要的时候获取任务的执⾏结果。std::future的⼀个重要特性是能够阻塞当前线程，直到异步操作完成，从⽽确保我们在获取结果时不会遇到未完成的操作。

应用场景

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

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

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

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

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

        std::async是⼀种将任务与std::future关联的简单⽅法。它创建并运⾏⼀个异步任务，并返回⼀个与该任务结果关联的std::future对象。默认情况下，std::async是否启动⼀个新线程，或者在等待future时，任务是否同步运⾏都取决于你给的 参数。这个参数为std::launch类型

◦ std::launch::deferred 表明该函数会被延迟调⽤，直到在future上调⽤get()或者wait()才会开始执⾏任务

◦ std::launch::async 表明函数会在⾃⼰创建的线程上运⾏

◦ std::launch::deferred | std::launch::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和future
    std::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配合

std::packaged_task就是将任务和 std::future 绑定在⼀起的模板，是⼀种对任务的封装。我们可以通过std::packaged_task对象获取任务相关联的std::future对象，通过调⽤get_future()⽅法获得。std::packaged_task的模板参数是函数签名。

可以把std::future和std::async看成是分开的， ⽽ std::packaged_task则是⼀个整体。

#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;
}

 运行可以看到

那么如何异步执⾏std::packaged_task任务

#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配合

        std::promise提供了⼀种设置值的⽅式，它可以在设置之后通过相关联的std::future对象进⾏读取。换种说法就是之前说过std::future可以读取⼀个异步函数的返回值了， 但是要等待就绪， ⽽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有值才能取