C++11的std::future对象如何使用

引言

在现代C++编程中，异步编程是一个非常重要的概念。C++11引入了std::future和std::promise等工具，使得异步编程变得更加简单和直观。本文将详细介绍std::future的使用方法，并通过示例代码帮助读者更好地理解其工作原理。

什么是std::future？

std::future是C++11标准库中的一个模板类，用于表示一个异步操作的结果。它允许我们在一个线程中启动一个异步任务，并在另一个线程中获取该任务的结果。std::future通常与std::async、std::promise或std::packaged_task一起使用。

std::future的基本用法

1. 使用std::async创建std::future

std::async是一个函数模板，用于启动一个异步任务，并返回一个std::future对象，该对象可以用来获取任务的结果。

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

int compute() {
    std::this_thread::sleep_for(std::chrono::seconds(2));
    return 42;
}

int main() {
    std::future<int> fut = std::async(std::launch::async, compute);
    std::cout << "Waiting for the result...\n";
    int result = fut.get();
    std::cout << "Result: " << result << "\n";
    return 0;
}

在这个例子中，std::async启动了一个异步任务compute，并返回一个std::future<int>对象fut。fut.get()会阻塞当前线程，直到compute函数返回结果。

2. 使用std::promise创建std::future

std::promise是另一个可以与std::future配合使用的类。std::promise允许我们在一个线程中设置一个值，并在另一个线程中通过std::future获取该值。

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

void compute(std::promise<int> prom) {
    std::this_thread::sleep_for(std::chrono::seconds(2));
    prom.set_value(42);
}

int main() {
    std::promise<int> prom;
    std::future<int> fut = prom.get_future();
    std::thread t(compute, std::move(prom));
    std::cout << "Waiting for the result...\n";
    int result = fut.get();
    std::cout << "Result: " << result << "\n";
    t.join();
    return 0;
}

在这个例子中，std::promise<int>对象prom用于在compute函数中设置值，而prom.get_future()返回的std::future<int>对象fut用于在主线程中获取该值。

3. 使用std::packaged_task创建std::future

std::packaged_task是一个类模板，用于将可调用对象（如函数、lambda表达式等）包装成一个异步任务，并返回一个std::future对象。

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

int compute() {
    std::this_thread::sleep_for(std::chrono::seconds(2));
    return 42;
}

int main() {
    std::packaged_task<int()> task(compute);
    std::future<int> fut = task.get_future();
    std::thread t(std::move(task));
    std::cout << "Waiting for the result...\n";
    int result = fut.get();
    std::cout << "Result: " << result << "\n";
    t.join();
    return 0;
}

在这个例子中，std::packaged_task<int()>对象task包装了compute函数，并通过task.get_future()返回一个std::future<int>对象fut。std::thread对象t启动任务，并在主线程中通过fut.get()获取结果。

std::future的高级用法

1. 检查std::future的状态

std::future提供了几个方法来检查异步任务的状态：

• valid()：检查std::future对象是否与一个共享状态相关联。
• wait()：阻塞当前线程，直到异步任务完成。
• wait_for()：阻塞当前线程一段时间，直到异步任务完成或超时。
• wait_until()：阻塞当前线程，直到异步任务完成或到达指定时间点。

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

int compute() {
    std::this_thread::sleep_for(std::chrono::seconds(2));
    return 42;
}

int main() {
    std::future<int> fut = std::async(std::launch::async, compute);
    if (fut.valid()) {
        std::cout << "Future is valid.\n";
    }
    std::future_status status = fut.wait_for(std::chrono::seconds(1));
    if (status == std::future_status::ready) {
        std::cout << "Task completed.\n";
    } else if (status == std::future_status::timeout) {
        std::cout << "Task is still running.\n";
    }
    int result = fut.get();
    std::cout << "Result: " << result << "\n";
    return 0;
}

在这个例子中，fut.wait_for(std::chrono::seconds(1))会阻塞当前线程1秒钟，如果任务在1秒钟内完成，则返回std::future_status::ready，否则返回std::future_status::timeout。

2. 使用std::future的异常处理

如果异步任务中抛出了异常，std::future的get()方法会重新抛出该异常。

#include <iostream>
#include <future>
#include <thread>
#include <stdexcept>

int compute() {
    throw std::runtime_error("Something went wrong!");
    return 42;
}

int main() {
    std::future<int> fut = std::async(std::launch::async, compute);
    try {
        int result = fut.get();
        std::cout << "Result: " << result << "\n";
    } catch (const std::exception& e) {
        std::cout << "Exception: " << e.what() << "\n";
    }
    return 0;
}

在这个例子中，compute函数抛出了一个异常，fut.get()会捕获并重新抛出该异常，主线程中的try-catch块会捕获并处理该异常。

3. 使用std::future的共享状态

std::future对象可以与多个std::shared_future对象共享同一个共享状态。std::shared_future允许多个线程等待同一个异步任务的结果。

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

int compute() {
    std::this_thread::sleep_for(std::chrono::seconds(2));
    return 42;
}

void print_result(std::shared_future<int> fut) {
    int result = fut.get();
    std::cout << "Result: " << result << "\n";
}

int main() {
    std::future<int> fut = std::async(std::launch::async, compute);
    std::shared_future<int> shared_fut = fut.share();
    std::thread t1(print_result, shared_fut);
    std::thread t2(print_result, shared_fut);
    t1.join();
    t2.join();
    return 0;
}

在这个例子中，fut.share()返回一个std::shared_future<int>对象shared_fut，该对象可以与多个线程共享同一个异步任务的结果。

总结

std::future是C++11中用于异步编程的重要工具，它允许我们在一个线程中启动一个异步任务，并在另一个线程中获取该任务的结果。通过std::async、std::promise和std::packaged_task，我们可以灵活地创建和管理std::future对象。此外，std::future还提供了丰富的接口来检查任务状态、处理异常以及共享任务结果。

希望本文能够帮助读者更好地理解和使用std::future，从而编写出更加高效和可靠的异步代码。