C++协程错误处理：std::future和std::promise的精妙运用

# 1. C++协程与并发编程基础

并发编程是现代编程中不可或缺的一部分，尤其是在处理高性能和实时系统时。C++作为一门强大的编程语言，不仅在传统的系统编程领域有着广泛的应用，其在并发编程上的支持也越来越受到开发者的青睐。C++11引入了对并发的支持，而C++20则进一步增加了协程这一强大的特性，为开发者提供了新的构建高效、易于理解的并发程序的能力。

## 1.1 并发与并行的基本概念
在深入C++协程之前，理解并发（Concurrency）和并行（Parallelism）的区别至关重要。并发是指在宏观上同时处理多个任务的能力，这不一定意味着任务在同一时刻被真实地执行；并行则是指在微观上多个任务在同一时刻真实地在多个处理核心上执行。并发是通过让处理器在多个任务之间快速切换来实现的，而并行则需要硬件的支持。

## 1.2 C++中的并发编程工具
C++标准库提供了多种工具来支持并发编程，包括线程（std::thread）、互斥量（std::mutex）、条件变量（std::condition_variable）等。这些工具可以用来创建多线程程序，实现任务的同步和通信。然而，这些底层工具的使用往往较为复杂，容易出现错误，如死锁和数据竞争等问题。

## 1.3 C++协程简介
C++20中引入的协程是一种提供非阻塞控制流的编程结构，它允许函数挂起执行，稍后再恢复。协程是C++并发编程范式的一个补充，它简化了并发程序的编写，使得异步操作的代码更加直观。通过协程，开发者可以以同步编程的方式来处理异步操作，极大地提高了程序的可读性和可维护性。

接下来的章节，我们将深入探讨C++中std::future和std::promise的使用，它们是C++标准库中用于异步操作的重要组件，它们与协程结合使用，可以轻松实现任务的并发执行和结果的获取。通过这种方式，我们可以构建出更加高效和响应迅速的应用程序。

# 2. 理解std::future和std::promise

## 2.1 std::future的概述与使用

### 2.1.1 std::future的基本概念

在C++11标准中引入的std::future是一种用于异步操作的同步机制，它提供了访问异步操作结果的途径。std::future对象代表着一个异步操作的最终结果，这个结果可能立即就绪，也可能要等待一段时间。通过std::future，我们可以查询异步操作的状态，获取异步操作的值，或者等待异步操作完成。

std::future通常与std::async函数配合使用，或者从std::promise对象中获取。std::future不能被复制，但可以被移动。当我们不再需要std::future对象时，应该销毁它，否则会造成资源泄漏。

### 2.1.2 std::future的创建和获取值

创建std::future最常见的方式是使用std::async启动异步任务：

#include <future>
#include <iostream>

int main() {
    // 使用std::async启动一个异步任务
    std::future<int> future = std::async(std::launch::async, []() {
        // 延迟2秒后返回一个值
        std::this_thread::sleep_for(std::chrono::seconds(2));
        return 88;
    });

    // 获取异步操作的结果，如果结果还没准备好，则当前线程会被阻塞
    int result = future.get();
    std::cout << "Result of future: " << result << std::endl;

    return 0;
}

在上面的代码中，通过std::async启动了一个异步任务，并返回了一个std::future对象。调用`.get()`方法会阻塞当前线程直到异步任务完成并返回结果。这是一个同步操作的例子，因为我们等待了异步任务的结果。

## 2.2 std::promise的概述与使用

### 2.2.1 std::promise的基本概念

std::promise是一种用于设置异步任务结果的工具，与std::future一起使用。它可以存储一个值或异常，然后这个值或异常可以被一个std::future对象检索。std::promise提供了一种在另一个线程中设置值，并在稍后在std::future中检索该值的方式。

std::promise对象通常通过它的get_future方法与一个std::future对象关联。一旦promise对象被销毁，通过这个promise对象创建的future对象就不能再用来获取值。

### 2.2.2 std::promise与值的传递

使用std::promise可以手动设置异步操作的结果：

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

void task(std::promise<int> prom) {
    // 设置异步任务的结果
    prom.set_value(42);
}

int main() {
    std::promise<int> prom;
    std::future<int> fut = prom.get_future();
    std::thread t(task, std::move(prom));

    // 等待异步任务完成并获取结果
    int result = fut.get();
    std::cout << "Received from future: " << result << std::endl;

    t.join();
    return 0;
}

在这个例子中，std::promise对象被用来手动设置值。我们通过std::move将promise传递给另一个线程执行的任务，然后在任务中调用`set_value`方法来存储结果。这个结果随后通过std::future的`get`方法检索。

## 2.3 std::future与std::promise的关联

### 2.3.1 如何通过promise设置future的值

std::promise和std::future之间的关联是通过共享状态来实现的。当一个std::promise对象通过其get_future方法关联一个std::future对象时，它们都会共享同一状态。这个状态包含了promise设置的值或者异常。

这里有一个具体的例子，说明如何通过promise设置future的值：

#include <future>
#include <iostream>

int main() {
    std::promise<int> prom;
    std::future<int> fut = prom.get_future();

    // 存储一个值到promise对象中
    prom.set_value(100);

    // 从future对象中获取这个值
    int value = fut.get();
    std::cout << "Value from future: " << value << std::endl;

    return 0;
}

### 2.3.2 future错误处理的机制

std::future提供了一种机制来处理与共享状态相关的错误。当异步任务中出现异常时，可以通过std::promise设置一个std::exception_ptr对象到future的共享状态中。随后，在调用future的get方法时可以捕获到这个异常。

下面是一个处理future错误的代码示例：

#include <future>
#include <iostream>

void task(std::promise<int> prom) {
    try {
        // 抛出一个异常
        throw std::runtime_error("An error occurred!");
    } catch (...) {
        // 将异常存储到promise中
        prom.set_exception(std::current_exception());
    }
}

int main() {
    std::promise<int> prom;
    std::future<int> fut = prom.get_future();

    // 在另一个线程中运行task函数
    std::thread t(task, std::move(prom));
    t.join();

    try {
        // 尝试获取值，如果存在异常，则抛出
        int value = fut.get();
    } catch (const std::runtime_error& e) {
        // 异常被捕获并处理
        std::cout << "Exception caught: " << e.what() << std::endl;
    } catch (...) {
        // 处理其他类型的异常
    }

    return 0;
}

在上面的代码中，当异常发生在task函数中时，它被存储在一个promise对象中。之后，当调用`fut.get()`时，这个异常会被抛出，并可以被相应的异常处理代码捕获和处理。

std::future的错误处理机制非常强大，它允许开发者在多个线程中传递错误信息，并在获取结果时进行统一的错误处理。这种机制使得异步编程更加安全和可靠。

# 3. C++协程错误处理技巧

在编写异步代码时，错误处理是极其重要的一个环节，尤其是在协程中，错误处理策略需要适应异步和非阻塞的特性。本章将深入探讨C++协程中异常的传播方式、使用`std::promise`传递异常的机制，以及如何避免常见的错误传播陷阱。

## 3.1 异步任务中的异常传播

### 3.1.1 异常在协程中的处理机制

在C++中，协程的异常处理机制与传统函数有所不同。当一个协程抛出异常时，这个异常会被传递到协程的下一个`co_await`点。如果异常没有被处理，它会传递到协程的启动器，最终可能导致程序终止。为了优雅地处理协程中的异常，我们可以使用`try-catch`块来捕获异常。

为了理解这一点，我们可以考虑一个简单的协程示例，该协程执行一些可能抛出异常的操作：

#include <coroutine>
#include <exception>
#include <iostream>
#include <memory>

struct Generator {
    struct Promise {
        int value;
        Generator get_return_object() { return Generator{std::coroutine_handle<Promise>::from_promise(*this)}; }
        std::suspend_always initial_suspend() { return {}; }
        std::suspend_always final_suspend() noexcept { return {}; }
        void unhandled_exception() {}
        void return_value(int v) { value = v; }
    };

    std::coroutine_handle<Promise> h;
    explicit Generator(std::coroutine_handle<Promise> h) : h(h) {}
    ~Generator() { h.destroy(); }

    int operator()() {
        try {
            // Simulate some asynchronous work that can throw
            if (co_await some_async_operation()) {
                co_return 42;
            } else {
                throw std::runtime_error("Async operation failed");
            }
        } catch (...) {
            h.promise().unhandled_exception();
            throw;
        }
    }
};

Generator some_async_operation() {
    co_await std::suspend_always{};
    throw std::runtime_error("Example exception");
}

int main() {
    auto gen = some_async_operation();
    try {
        int result = gen();
        std::cout << "Result: " << result << std::endl;
    } catch (const std::exception& e) {
        std::cout << "Caught exception: " << e.what() << std::endl;