C++11 新特性之future和packaged_task

C++11 新特性之future

#include <iostream>
#include <thread>
#include <future>
#include <chrono>


void test(std::promise<int>& probj){
    std::this_thread::sleep_for(std::chrono::seconds(5));
    probj.set_value(20);
}


int main(){
    std::promise<int> obj;
    std::future<int> features = obj.get_future();
    std::thread th(test, std::ref(obj));
    int ans = features.get();
    std::cout<<"value: "<<ans<<std::endl;
    th.join();
    return 0;
}

packaged_task 和 async() 是 C++ 中用于实现异步任务的工具。

packaged_task 是一个类模板，它允许将函数或可调用对象封装为一个异步任务。它包装了一个函数或可调用对象，并可以通过调用 operator() 来执行该任务。同时，它还提供了一个与该任务关联的 std::future 对象，用于获取任务的结果。
使用 packaged_task 的一般步骤如下：

1、创建一个 packaged_task 对象，并将要执行的函数或可调用对象传递给它的构造函数。
通过调用 get_future() 获取与 packaged_task 关联的 std::future 对象，用于获取任务的返回值。
2、将 packaged_task 对象传递给一个线程或者其他异步执行的机制，以便在另一个线程上执行任务。
3、在需要获取结果时，通过调用 std::future 对象的 get() 方法来等待任务完成并获取结果。

packaged_task 提供了一种将异步任务与其结果关联起来的方式，使得在一个线程中执行任务并在另一个线程中获取结果变得更加方便。

#include <iostream>
#include <thread>
#include <future>
#include <chrono>

int add(int a, int b){
    std::this_thread::sleep_for(std::chrono::seconds(2));
    return a+b;
}

int main(){
    
    // 将任务函数进行打包
    std::packaged_task<int(int, int)> task(add);
    
    std::future<int> futureObj = task.get_future();
    std::thread th(std::move(task), 10, 20);
    
    
    int ans = futureObj.get();
    std::cout<<ans<<std::endl;
    th.join();
    return  0;
}

当使用 std::async() 函数时，可以通过指定不同的策略来控制任务的执行方式。这里有三种策略可供选择：

默认策略（默认参数）：

当没有指定策略时，std::async() 将使用默认策略。这里的默认策略是由编译器和运行时环境决定的，其行为可以是在新线程中执行任务，也可以是在当前线程中执行任务。编译器和运行时环境会根据系统资源、负载和其他因素来选择最佳的执行方式。

例如，如果当前线程已经有空闲的线程资源可用，编译器可能会决定在当前线程中执行任务。这样可以避免额外的线程创建和上下文切换开销。

无论任务在哪个线程中执行，你仍然可以使用 std::future 对象来获取任务的结果。

std::launch::async 策略：

使用 std::launch::async 标志作为 std::async() 的第一个参数，可以显式地要求任务在新线程中执行。这将确保任务在新线程中独立地执行，而不会占用当前线程。

例如，以下代码将使用 std::launch::async 策略来启动一个异步任务，任务将在新线程中执行：

std::future<int> futureObj = std::async(std::launch::async, add, 10, 20);

使用 std::launch::async 策略时，std::async() 函数将创建一个新线程来执行任务，从而实现异步执行。

std::launch::deferred 策略：

使用 std::launch::deferred 标志作为 std::async() 的第一个参数，可以延迟任务的执行。这意味着任务将不会立即在新线程中执行，而是在调用 std::future 对象的 get() 或 wait() 方法时执行。

例如，以下代码将使用 std::launch::deferred 策略来启动一个延迟执行的任务：

std::future<int> futureObj = std::async(std::launch::deferred, add, 10, 20);

使用 std::launch::deferred 策略时，std::async() 函数不会创建新线程。相反，任务的执行将延迟到调用 get() 或 wait() 方法时，可能在当前线程中执行。

需要注意的是，这些策略的行为取决于编译器和运行时环境的实现，所以具体的结果可能因实际情况而异。默认策略是最常用的，它会根据环境自动选择最佳的执行方式。如果需要确保任务在新线程中执行，可以使用 std::launch::async 策略。如果需要延迟任务的执行，可以使用 std::launch::deferred 策略。但请注意，延迟执行的任务只会在调用 get() 或 wait() 方法时执行，而不会在后台线程中进行。