C++并发编程实践：深入理解Future机制

柯晶辰Godfrey

于 2025-06-08 09:02:11 发布

阅读量325

点赞数 5

CC 4.0 BY-SA版权

本文链接：https://blog.youkuaiyun.com/gitblog_00403/article/details/148505508

C++并发编程实践：深入理解Future机制

Cplusplus-Concurrency-In-Practice A Detailed Cplusplus Concurrency Tutorial 《C++ 并发编程指南》项目地址: https://gitcode.com/gh_mirrors/cp/Cplusplus-Concurrency-In-Practice

概述

在现代C++并发编程中，Future机制是一种非常重要的异步编程工具。本文将深入探讨std::future、std::shared_future及其相关组件，帮助开发者掌握这一强大的并发编程工具。

Future核心概念

什么是Future？

std::future是C++11引入的一个模板类，它提供了一种访问异步操作结果的机制。简单来说，Future就像一个"承诺"，它代表一个可能在将来可用的值。我们可以把Future想象成一个异步任务的收据，凭借这个收据，我们可以在未来某个时刻获取任务的结果。

Future的工作原理

异步任务发起：通过std::async、std::promise或std::packaged_task创建一个异步任务
Future获取：从上述对象中获取一个Future对象
结果等待：在需要结果时，通过Future对象获取（可能会阻塞等待）
结果获取：当异步任务完成后，通过Future获取结果或异常

std::future详解

创建有效的Future对象

有效的Future对象通常通过以下三种方式创建：

std::async函数：最常用的创建方式
std::promise::get_future：用于显式设置值或异常
std::packaged_task::get_future：将函数调用与Future关联

// 示例：三种创建Future的方式
auto fut1 = std::async([](){ return 42; });  // 方式1

std::promise<int> prom;
auto fut2 = prom.get_future();               // 方式2

std::packaged_task<int()> task([](){ return 42; });
auto fut3 = task.get_future();               // 方式3

Future的状态管理

每个Future对象都有一个关联的共享状态，这个状态可以是：

非就绪(not ready)：异步操作尚未完成
就绪(ready)：异步操作已完成，结果可用
无效(invalid)：未关联任何共享状态

std::future<int> empty_fut;  // 默认构造，无效状态
if(!empty_fut.valid()) {
    std::cout << "Future对象无效\n";
}

获取结果：get()方法

get()方法是Future的核心功能，它有三种形式：

通用模板：T get()
引用特化：R& future<R&>::get()
void特化：void future<void>::get()

std::future<int> fut = std::async([](){ return 42; });
int result = fut.get();  // 阻塞直到结果可用

重要特性：

get()是一次性操作，调用后Future变为无效
如果异步操作抛出异常，get()会重新抛出该异常

等待机制

C++提供了多种等待Future完成的机制：

wait()：无限期等待直到结果就绪
wait_for()：等待指定时间段
wait_until()：等待到指定时间点

std::future<int> fut = std::async(long_running_task);

// 方式1：简单等待
fut.wait();

// 方式2：超时等待
auto status = fut.wait_for(std::chrono::seconds(1));
if(status == std::future_status::ready) {
    // 任务完成
}

// 方式3：绝对时间点等待
auto deadline = std::chrono::system_clock::now() + std::chrono::seconds(1);
status = fut.wait_until(deadline);

std::shared_future详解

为什么需要shared_future？

std::future有一个重要限制：它是只能移动(move-only)的类型，且get()只能调用一次。这意味着我们不能在多个地方共享同一个Future的结果。std::shared_future解决了这个问题。

shared_future的特性

可复制：可以被多次复制
共享结果：多个shared_future可以访问同一个异步结果
多次get()：可以多次调用get()获取结果

std::future<int> fut = std::async([](){ return 42; });
std::shared_future<int> shared_fut = fut.share();  // 转换为shared_future

// 现在可以在多个地方使用
auto result1 = shared_fut.get();
auto result2 = shared_fut.get();  // 可以多次调用

shared_future的使用场景

多个消费者：当多个线程需要访问同一个异步结果时
结果缓存：需要多次访问计算结果时
观察者模式：多个观察者观察同一个异步事件的结果

实际应用示例

素数检查示例

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

bool is_prime(int x) {
    for(int i = 2; i < x; ++i)
        if(x % i == 0) return false;
    return true;
}

int main() {
    std::future<bool> fut = std::async(is_prime, 444444443);
    
    std::cout << "检查中，请稍候";
    while(fut.wait_for(std::chrono::milliseconds(100)) {
        std::cout << '.';
    }
    
    bool result = fut.get();
    std::cout << "\n444444443 " << (result ? "是" : "不是") << "素数\n";
    return 0;
}

多线程结果共享示例

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

void worker(std::shared_future<int> shared_fut) {
    int result = shared_fut.get();
    std::cout << "Worker got: " << result << std::endl;
}

int main() {
    std::promise<int> prom;
    std::shared_future<int> shared_fut = prom.get_future().share();
    
    std::vector<std::thread> workers;
    for(int i = 0; i < 5; ++i) {
        workers.emplace_back(worker, shared_fut);
    }
    
    prom.set_value(42);  // 所有worker将同时收到结果
    
    for(auto& t : workers) {
        t.join();
    }
    return 0;
}