C++并发编程：void future/promise实现线程间事件通信

1. 为什么需要一次性事件通信机制

在现代C++并发编程中，线程间通信是一个核心挑战。想象这样一个场景：你正在开发一个视频处理应用，主线程需要等待后台线程完成视频解码后才能开始渲染。这种"等待某个事件发生"的模式，就是典型的一次性事件通信（one-shot event communication）。

传统做法是使用条件变量（condition variable），但这带来了几个棘手问题：

• 虚假唤醒：条件变量可能在没有通知的情况下返回，需要额外状态变量配合
• 竞态条件：如果通知在等待之前发出，信号就会丢失
• 复杂性：需要手动管理互斥锁和状态标志

cpp复制// 传统条件变量实现示例
std::mutex m;
std::condition_variable cv;
bool ready = false;

void worker_thread() {
    // 模拟工作
    std::this_thread::sleep_for(std::chrono::seconds(1));
    
    {
        std::lock_guard<std::mutex> lk(m);
        ready = true;
    }
    cv.notify_one();
}

int main() {
    std::thread t(worker_thread);
    
    {
        std::unique_lock<std::mutex> lk(m);
        cv.wait(lk, []{return ready;});  // 可能虚假唤醒
    }
    
    t.join();
}

2. void future/promise 的工作原理

C++11引入的std::future/std::promise对提供了一种更优雅的解决方案。这对工具本质上是一个线程安全的单次写入容器：

• promise：作为数据的生产者端
• future：作为数据的消费者端
• 共享状态：两者之间的同步点

当我们需要纯事件通知（不传递实际数据）时，可以使用void特化版本：

cpp复制std::promise<void> p;
auto f = p.get_future();  // 获取关联的future

// 线程A（生产者）
p.set_value();  // 触发事件

// 线程B（消费者）
f.get();  // 阻塞直到事件发生

关键优势在于：

1. 隐式同步：共享状态已经内置了必要的同步机制
2. 无数据竞争：set_value和get的调用顺序由库保证安全
3. 一次性语义：确保事件只被处理一次

3. 实际应用场景与实现示例

3.1 线程启动同步

在视频处理应用中，我们可能需要在所有解码线程准备就绪后才开始处理：

cpp复制std::promise<void> start_promise;
auto start_future = start_promise.get_future();

void decoder_thread(int id) {
    start_future.wait();  // 等待启动信号
    std::cout << "Thread " << id << " started processing\n";
    // 实际解码工作...
}

int main() {
    std::vector<std::thread> threads;
    for (int i = 0; i < 5; ++i) {
        threads.emplace_back(decoder_thread, i);
    }
    
    std::this_thread::sleep_for(std::chrono::seconds(1));  // 模拟准备时间
    start_promise.set_value();  // 触发所有线程开始
    
    for (auto& t : threads) {
        t.join();
    }
}

3.2 超时处理

结合std::future的超时等待能力，我们可以实现带超时的事件等待：

cpp复制std::promise<void> p;
auto f = p.get_future();

void worker() {
    std::this_thread::sleep_for(std::chrono::seconds(3));
    p.set_value();
}

int main() {
    std::thread t(worker);
    
    if (f.wait_for(std::chrono::seconds(2)) == 
        std::future_status::timeout) {
        std::cout << "Timeout occurred\n";
    }
    
    t.join();
}

4. 与条件变量的性能对比

在Linux (gcc 10.2)环境下实测100,000次事件通知：

虽然微观性能差异不大，但future/promise在以下方面明显占优：

• 更简洁的API
• 更少的手动同步
• 更低的出错概率

5. 常见陷阱与最佳实践

5.1 promise生命周期管理

promise对象必须比关联的future存活时间长，否则会导致std::future_error异常：

cpp复制std::future<void> create_future() {
    std::promise<void> p;  // 临时对象
    return p.get_future(); // 错误！p将立即销毁
}

正确做法是使用shared_ptr管理promise：

cpp复制std::future<void> create_future() {
    auto p = std::make_shared<std::promise<void>>();
    return p->get_future();
}

5.2 多次set_value问题

void promise虽然不携带数据，但仍遵循单次写入原则。多次调用set_value会导致std::future_error：

cpp复制std::promise<void> p;
p.set_value();
p.set_value();  // 抛出异常

5.3 异常处理

promise也可以传递异常，这在错误处理中非常有用：

cpp复制void worker(std::promise<void>& p) {
    try {
        // 可能抛出异常的操作
        throw std::runtime_error("Something went wrong");
        p.set_value();
    } catch(...) {
        p.set_exception(std::current_exception());
    }
}

int main() {
    std::promise<void> p;
    auto f = p.get_future();
    
    std::thread t(worker, std::ref(p));
    
    try {
        f.get();
    } catch(const std::exception& e) {
        std::cerr << "Error: " << e.what() << '\n';
    }
    
    t.join();
}

6. 高级应用模式

6.1 多future组合

使用std::shared_future可以实现多个消费者等待同一事件：

cpp复制std::promise<void> p;
auto sf = p.get_future().share();  // 转换为shared_future

void worker(int id) {
    sf.wait();
    std::cout << "Worker " << id << " activated\n";
}

int main() {
    std::vector<std::thread> threads;
    for (int i = 0; i < 3; ++i) {
        threads.emplace_back(worker, i);
    }
    
    p.set_value();
    
    for (auto& t : threads) {
        t.join();
    }
}

6.2 与async结合

std::async内部也使用promise/future机制，可以无缝配合：

cpp复制auto future = std::async(std::launch::async, []{
    std::this_thread::sleep_for(std::chrono::seconds(1));
    return 42;
});

// 同时等待多个事件
std::promise<void> p;
auto f = p.get_future();

std::thread t([&p]{
    std::this_thread::sleep_for(std::chrono::milliseconds(500));
    p.set_value();
});

auto status = future.wait_for(std::chrono::seconds(2));
if (status == std::future_status::ready) {
    std::cout << "Result: " << future.get() << '\n';
}

f.wait();
t.join();

7. 替代方案比较

虽然void future很实用，但在某些场景下可能有更好的选择：

在实际项目中，我通常会根据以下标准做选择：

1. 事件是否真的只需要触发一次？
2. 是否需要跨线程异常传递？
3. 性能是否在关键路径上？
4. 代码可读性与维护成本

void future在90%的一次性事件场景中都是最佳选择，特别是当代码清晰度比微秒级性能差异更重要时。