C++11 异步编程入门教程-洪萨配资

1. 概述

C++11 引入了<future>头文件，提供了一套标准化的异步编程工具，用于简化多线程编程和异步任务管理。这套工具主要包括std::future、std::shared_future、std::async、std::promise、std::packaged_task等组件。

2. std::future

std::future是一个模板类，用于获取异步操作的结果。它代表一个“未来”的值，当异步操作完成后，可以通过它获取结果。

常用接口

get(): 获取结果，如果结果未就绪则阻塞等待
valid(): 检查 future 是否关联了共享状态
wait(): 阻塞等待结果就绪
wait_for(): 等待一段时间，返回状态
wait_until(): 等待到指定时间点，返回状态

示例代码

#include <iostream> #include <future> #include <thread> #include <chrono> int calculate() { std::this_thread::sleep_for(std::chrono::seconds(2)); // 模拟耗时计算 return 42; } int main() { // 启动异步任务 std::future<int> fut = std::async(std::launch::async, calculate); std::cout << "Doing other work..." << std::endl; // 获取结果（会阻塞直到结果就绪） int result = fut.get(); std::cout << "Result: " << result << std::endl; return 0; }

3. std::shared_future

std::shared_future是std::future的共享版本，可以被多个线程安全地访问。与std::future不同，shared_future的get()方法可以多次调用。

常用接口

get(): 获取结果（可多次调用）
valid(): 检查是否有效
wait(): 等待结果

示例代码

#include <iostream> #include <future> #include <vector> #include <thread> void worker(std::shared_future<int> sf) { // 多个线程可以安全地访问同一个 shared_future int result = sf.get(); std::cout << "Thread " << std::this_thread::get_id() << " got result: " << result << std::endl; } int main() { std::promise<int> prom; std::shared_future<int> sf = prom.get_future(); // 创建多个线程共享同一个 future std::vector<std::thread> threads; for (int i = 0; i < 3; ++i) { threads.emplace_back(worker, sf); } // 设置值 prom.set_value(100); for (auto& t : threads) { t.join(); } return 0; }

4. std::async

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

启动策略（std::launch）

std::launch::async: 在新线程中异步执行
std::launch::deferred: 延迟执行（调用 get() 时执行）
std::launch::async | std::launch::deferred: 默认策略，由实现决定

示例代码

#include <iostream> #include <future> #include <chrono> int heavy_computation(int x) { std::this_thread::sleep_for(std::chrono::seconds(1)); return x * x; } int main() { // 异步执行（立即在新线程中启动） auto fut1 = std::async(std::launch::async, heavy_computation, 10); // 延迟执行（调用 get() 时才执行） auto fut2 = std::async(std::launch::deferred, heavy_computation, 20); std::cout << "fut1 is running asynchronously..." << std::endl; // 获取异步结果 int result1 = fut1.get(); std::cout << "Result1: " << result1 << std::endl; // 此时才开始执行 fut2 int result2 = fut2.get(); std::cout << "Result2: " << result2 << std::endl; return 0; }

5. std::promise

std::promise用于在线程之间传递结果。它提供了一个“承诺”，可以在未来某个时间点设置值，并通过关联的std::future获取该值。

常用接口

get_future(): 获取关联的 future 对象
set_value(): 设置值
set_exception(): 设置异常

示例代码

#include <iostream> #include <future> #include <thread> #include <stdexcept> void producer(std::promise<int> prom) { try { std::this_thread::sleep_for(std::chrono::seconds(1)); prom.set_value(42); // 设置结果 } catch (...) { prom.set_exception(std::current_exception()); // 设置异常 } } int main() { std::promise<int> prom; std::future<int> fut = prom.get_future(); std::thread t(producer, std::move(prom)); try { int result = fut.get(); std::cout << "Received result: " << result << std::endl; } catch (const std::exception& e) { std::cout << "Exception: " << e.what() << std::endl; } t.join(); return 0; }

6. std::packaged_task

std::packaged_task是一个可调用对象的包装器，它可以将函数调用与其结果关联起来。类似于std::function，但多了获取 future 的功能。

常用接口

get_future(): 获取关联的 future
operator(): 执行任务
valid(): 检查是否有效

示例代码

#include <iostream> #include <future> #include <thread> int multiply(int x, int y) { return x * y; } int main() { // 包装一个函数 std::packaged_task<int(int, int)> task(multiply); std::future<int> fut = task.get_future(); // 在另一个线程中执行任务 std::thread t(std::move(task), 6, 7); // 获取结果 int result = fut.get(); std::cout << "6 * 7 = " << result << std::endl; t.join(); return 0; }

7. std::future_status

std::future_status是一个枚举类，用于表示等待操作的结果状态。

状态值

future_status::ready: 结果已就绪
future_status::timeout: 超时（结果未就绪）
future_status::deferred: 任务被延迟执行

示例代码

#include <iostream> #include <future> #include <chrono> int slow_function() { std::this_thread::sleep_for(std::chrono::seconds(3)); return 100; } int main() { auto fut = std::async(std::launch::async, slow_function); // 等待 1 秒 auto status = fut.wait_for(std::chrono::seconds(1)); if (status == std::future_status::ready) { std::cout << "Result is ready!" << std::endl; std::cout << "Value: " << fut.get() << std::endl; } else if (status == std::future_status::timeout) { std::cout << "Timeout: result not ready yet" << std::endl; } else if (status == std::future_status::deferred) { std::cout << "Task is deferred" << std::endl; } // 最终获取结果 std::cout << "Final result: " << fut.get() << std::endl; return 0; }

8. 综合示例：生产者-消费者模式

#include <iostream> #include <future> #include <thread> #include <queue> #include <mutex> #include <condition_variable> template<typename T> class ThreadSafeQueue { private: std::queue<T> queue_; std::mutex mutex_; std::condition_variable cond_; public: void push(T value) { std::lock_guard<std::mutex> lock(mutex_); queue_.push(std::move(value)); cond_.notify_one(); } T pop() { std::unique_lock<std::mutex> lock(mutex_); cond_.wait(lock, [this]{ return !queue_.empty(); }); T value = std::move(queue_.front()); queue_.pop(); return value; } }; void producer(ThreadSafeQueue<std::promise<int>>& queue, int count) { for (int i = 0; i < count; ++i) { std::promise<int> prom; auto fut = prom.get_future(); queue.push(std::move(prom)); // 模拟生产耗时 std::this_thread::sleep_for(std::chrono::milliseconds(100)); prom.set_value(i * i); // 设置结果 } } void consumer(ThreadSafeQueue<std::promise<int>>& queue, int count) { for (int i = 0; i < count; ++i) { auto prom = queue.pop(); auto fut = prom.get_future(); int result = fut.get(); std::cout << "Consumed: " << result << std::endl; } } int main() { ThreadSafeQueue<std::promise<int>> queue; std::thread prod(producer, std::ref(queue), 5); std::thread cons(consumer, std::ref(queue), 5); prod.join(); cons.join(); return 0; }