Effective Modern C++ 条款 39：一次性事件通信的优雅方案

二、void Futures：简约而不简单

2.1 核心思想：无数据的信号传递

std::promise<void> 和 std::future<void> 的组合提供了一种巧妙的解决方案——它们建立了一个通信信道，专门用于传递"某事已发生"的信号，而不需要传递具体数据。

std::promise<void> event_promise;

// 检测线程 - 简洁高效
void detect_task(){
    // ... 执行检测逻辑
    event_promise.set_value(); // 发出信号：事件已发生！
}

// 反应线程 - 优雅等待
void react_task(){
    // ... 准备工作
    event_promise.get_future().wait(); // 优雅阻塞，等待信号
    // ... 事件发生后的处理
}

2.2 技术优势矩阵

2.3 实际应用案例：延迟初始化的线程池

考虑一个高性能服务器应用，需要在启动时创建线程池，但希望延迟线程的实际执行，直到所有配置加载完成：

class ThreadPool {
private:
    std::promise<void> startup_promise;
    std::vector<std::thread> workers;

public:
    ThreadPool(size_t num_threads) {
        auto startup_future = startup_promise.get_future().share();
        for (size_t i = 0; i < num_threads; ++i) {
            workers.emplace_back([startup_future, i]{
                // 线程创建后立即挂起
                startup_future.wait();
                // 配置加载完成后开始工作
                std::cout << "Worker " << i << " starting...\n";
                // ... 工作逻辑
            });
        }
    }

    void start() {
        // 加载配置、初始化资源
        load_configuration();
        initialize_resources();
        // 唤醒所有工作线程
        startup_promise.set_value();
    }

    ~ThreadPool() {
        for (auto& worker : workers) {
            if (worker.joinable()) worker.join();
        }
    }
};

三、高级模式与变体

3.1 多接收者扩展

当需要通知多个等待线程时，std::shared_future<void> 展现出其独特价值：

std::promise<void> global_event;
auto shared_future = global_event.get_future().share();

// 多个反应线程
std::vector<std::thread> reactors;
for (int i = 0; i < 5; ++i) {
    reactors.emplace_back([shared_future, i]{
        // 每个线程持有 shared_future 的副本
        shared_future.wait();
        std::cout << "Reactor " << i << " activated!\n";
    });
}

// 触发所有线程
global_event.set_value();

3.2 超时与错误处理

增强的 wait 机制可以处理超时和异常：

std::promise<void> event_promise;
std::future<void> event_future = event_promise.get_future();

// 带超时的等待
if (event_future.wait_for(std::chrono::seconds(5)) == std::future_status::timeout) {
    std::cerr << "等待超时，执行备用方案\n";
    execute_fallback();
}

// 异常传播
try {
    event_promise.set_exception(std::make_exception_ptr(
        std::runtime_error("初始化失败")));
} catch (...) {
    event_promise.set_exception(std::current_exception());
}

四、性能考量与权衡

4.1 内存开销分析

promise/future 机制需要在堆上分配共享状态，这是其主要的内存开销来源。对于性能极其敏感的场景，这可能是一个考虑因素。相比原子标志的零开销，Futures 多了对象构造和堆分配的代价，但在大多数业务场景中，这种开销是可以接受的。

4.2 适用场景决策树

• 需要重复通知？ → 是 → 使用条件变量
• 需要传递数据？ → 是 → 使用 template promise/future
• 对内存开销极其敏感？ → 是 → 考虑原子标志 + 退避策略
• 否 → 使用 void promise/future ✓

五、现代 C++ 的进一步演进

C++20 引入了 std::latch 和 std::barrier，为同步操作提供了更丰富的工具：

// C++20 的更简洁方案
std::latch initialization_latch{1}; // 计数为 1

// 检测线程
void initialize_system(){
    perform_initialization();
    initialization_latch.count_down(); // 减少计数，释放等待者
}

// 反应线程
void process_data(){
    initialization_latch.wait(); // 等待计数变为 0
    start_processing();
}

然而，void futures 方案仍然有其独特优势——更细粒度的控制、与异常处理的自然集成，以及更好的可组合性。

结语：选择的艺术

在并发编程的世界里，没有银弹，只有合适的工具用于合适的场景。void 的 futures 为我们提供了一种优雅、安全且高效的一次性事件通信机制。它如同并发交响乐中的精准节拍器，确保各个线程在正确的时刻开始演奏。

记住这些关键要点：

• 精准定位：明确你的通信是一次性的
• 权衡利弊：在简洁性与内存开销间找到平衡
• 工具升级：随着 C++ 标准演进，关注新的同步原语

最终，优秀的并发代码不仅是正确的，更是清晰、可维护且优雅的。void futures 正是这种优雅哲学的体现——用最少的机制解决最核心的问题，让代码自己讲述其设计意图。