目录

一、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和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配合

#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有值才能取