WEBKT

C++协程的灵魂摆渡者？`coroutine_handle`使用详解和高级特性剖析

81 0 0 0

C++协程的灵魂摆渡者？coroutine_handle使用详解和高级特性剖析

什么是 coroutine_handle？

coroutine_handle 的作用

coroutine_handle 的成员函数

coroutine_handle 的生命周期管理

高级特性：coroutine_handle::from_address()

异常处理与 coroutine_handle

总结

C++协程的灵魂摆渡者？coroutine_handle使用详解和高级特性剖析

C++20 引入的协程，为我们提供了一种编写并发程序的全新方式。它允许我们在不使用传统线程的情况下，编写出看似异步但实际是同步执行的代码。而 coroutine_handle，就像是协程的灵魂摆渡者，是连接协程外部世界和协程内部状态的关键桥梁。今天，我们就来深入剖析 coroutine_handle，看看它究竟是如何工作的，以及如何利用它来控制协程的生命周期。

什么是 coroutine_handle？

简单来说，coroutine_handle 是一个不拥有所有权的句柄，指向协程帧（coroutine frame）。协程帧是编译器为协程创建的一块内存区域，用于存储协程的状态，包括局部变量、参数、挂起点等等。coroutine_handle 本身并不负责管理协程帧的生命周期，它只是一个指针，允许我们从协程外部访问和控制协程的执行。

coroutine_handle 有两种形式：

  • std::coroutine_handle<void>：指向一个类型未知的协程帧。
  • std::coroutine_handle<Promise>：指向一个特定 Promise 类型的协程帧，Promise 是协程的控制中心，负责管理协程的返回值、异常处理等。

coroutine_handle 的作用

coroutine_handle 的主要作用体现在以下几个方面：

  1. 恢复协程执行： 通过 resume() 方法，我们可以从协程挂起的地方继续执行。
  2. 销毁协程帧： 通过 destroy() 方法，我们可以释放协程帧所占用的内存。
  3. 获取 Promise 对象： 如果 coroutine_handle 是 std::coroutine_handle<Promise> 类型，我们可以通过 promise() 方法获取协程的 Promise 对象，从而访问协程的返回值、异常信息等。
  4. 检查协程状态： 通过 done() 方法，我们可以判断协程是否已经执行完成。

coroutine_handle 的成员函数

下面我们来详细看看 coroutine_handle 提供的几个关键成员函数：

  • resume()： 恢复协程的执行。协程会从上次挂起的地方继续执行，直到遇到下一个挂起点或执行完成。如果协程已经执行完成或已被销毁，调用 resume() 会导致未定义行为。

    		#include <iostream>
    		#include <coroutine>
    		 
    		struct MyCoroutine {
    		    struct promise_type {
    		        int value;
    		        MyCoroutine get_return_object() {
    		            return {std::coroutine_handle<promise_type>::from_promise(*this)};
    		        }
    		        std::suspend_never initial_suspend() { return {}; }
    		        std::suspend_never final_suspend() noexcept { return {}; }
    		        void unhandled_exception() {}
    		    };
    		    std::coroutine_handle<promise_type> handle;
    		};
    		 
    		MyCoroutine simpleCoroutine() {
    		    std::cout << "Coroutine started" << std::endl;
    		    co_await std::suspend_always{};
    		    std::cout << "Coroutine resumed" << std::endl;
    		}
    		 
    		int main() {
    		    MyCoroutine coro = simpleCoroutine();
    		    coro.handle.resume(); // 恢复协程执行
    		    std::cout << "Main function continues" << std::endl;
    		    coro.handle.resume(); // 再次恢复协程执行，但协程已经完成
    		    return 0;
    		}

    注意事项：

    • 必须确保协程处于挂起状态才能调用 resume()，否则会导致未定义行为。
    • 多次调用 resume() 会导致协程多次执行挂起点之间的代码。

  • destroy()： 销毁协程帧，释放其占用的内存。调用 destroy() 后，coroutine_handle 将变为无效，不能再用于访问或控制协程。如果协程正在执行，调用 destroy() 会导致未定义行为。

    		#include <iostream>
    		#include <coroutine>
    		 
    		struct MyCoroutine {
    		    struct promise_type {
    		        int value;
    		        MyCoroutine get_return_object() {
    		            return {std::coroutine_handle<promise_type>::from_promise(*this)};
    		        }
    		        std::suspend_never initial_suspend() { return {}; }
    		        std::suspend_never final_suspend() noexcept { return {}; }
    		        void unhandled_exception() {}
    		        ~promise_type() { std::cout << "Promise destroyed" << std::endl; }
    		    };
    		    std::coroutine_handle<promise_type> handle;
    		};
    		 
    		MyCoroutine simpleCoroutine() {
    		    std::cout << "Coroutine started" << std::endl;
    		    co_return;
    		}
    		 
    		int main() {
    		    MyCoroutine coro = simpleCoroutine();
    		    coro.handle.destroy(); // 销毁协程帧
    		    return 0;
    		}

    注意事项：

    • 必须确保协程已经执行完成或已被挂起才能调用 destroy()，否则会导致未定义行为。
    • 调用 destroy() 后，必须确保不再使用该 coroutine_handle。

  • promise()： 返回与协程关联的 Promise 对象的引用。只有当 coroutine_handle 是 std::coroutine_handle<Promise> 类型时才能调用此方法。通过 Promise 对象，我们可以访问协程的返回值、异常信息等。

    		#include <iostream>
    		#include <coroutine>
    		 
    		struct MyCoroutine {
    		    struct promise_type {
    		        int result;
    		        MyCoroutine get_return_object() {
    		            return {std::coroutine_handle<promise_type>::from_promise(*this)};
    		        }
    		        std::suspend_never initial_suspend() { return {}; }
    		        std::suspend_never final_suspend() noexcept { return {}; }
    		        void unhandled_exception() {}
    		        void return_value(int value) { result = value; }
    		    };
    		    std::coroutine_handle<promise_type> handle;
    		};
    		 
    		MyCoroutine returnCoroutine() {
    		    co_return 42;
    		}
    		 
    		int main() {
    		    MyCoroutine coro = returnCoroutine();
    		    auto& promise = coro.handle.promise();
    		    std::cout << "Result: " << promise.result << std::endl; // 访问协程的返回值
    		    coro.handle.destroy();
    		    return 0;
    		}

    注意事项：

    • 必须确保 coroutine_handle 指向的是一个有效的协程帧，才能调用 promise()，否则会导致未定义行为。

  • done()： 检查协程是否已经执行完成。如果协程已经执行到 final_suspend 点，或者因为异常而终止，done() 方法会返回 true，否则返回 false。

    		#include <iostream>
    		#include <coroutine>
    		 
    		struct MyCoroutine {
    		    struct promise_type {
    		        int value;
    		        MyCoroutine get_return_object() {
    		            return {std::coroutine_handle<promise_type>::from_promise(*this)};
    		        }
    		        std::suspend_never initial_suspend() { return {}; }
    		        std::suspend_never final_suspend() noexcept { return {}; }
    		        void unhandled_exception() {}
    		    };
    		    std::coroutine_handle<promise_type> handle;
    		};
    		 
    		MyCoroutine simpleCoroutine() {
    		    std::cout << "Coroutine started" << std::endl;
    		    co_return;
    		}
    		 
    		int main() {
    		    MyCoroutine coro = simpleCoroutine();
    		    if (coro.handle.done()) {
    		        std::cout << "Coroutine is done" << std::endl;
    		    } else {
    		        std::cout << "Coroutine is not done" << std::endl;
    		    }
    		    coro.handle.destroy();
    		    return 0;
    		}

    注意事项：

    • done() 方法只能用于判断协程是否已经执行完成，不能用于判断协程是否可以恢复执行。

coroutine_handle 的生命周期管理

coroutine_handle 本身并不拥有协程帧的所有权，因此在使用 coroutine_handle 时，我们需要特别注意协程帧的生命周期管理。一般来说，协程帧的生命周期由以下几个因素决定：

  • 协程的挂起和恢复： 协程帧在协程首次挂起时创建，并在协程最终完成或被销毁时释放。
  • coroutine_handle 的作用域： coroutine_handle 的作用域不应超过协程帧的生命周期，否则会导致悬空指针。
  • 异常处理： 如果协程抛出异常，我们需要确保协程帧能够被正确销毁，避免内存泄漏。

下面是一些关于 coroutine_handle 生命周期管理的建议：

  • 使用 RAII： 使用 RAII（Resource Acquisition Is Initialization）原则来管理 coroutine_handle，确保在 coroutine_handle 不再使用时，协程帧能够被自动销毁。
  • 避免悬空指针： 避免在协程帧被销毁后继续使用 coroutine_handle，可以使用智能指针来管理 coroutine_handle，并在协程帧被销毁时自动重置 coroutine_handle。
  • 处理异常： 在协程中合理处理异常，确保即使发生异常，协程帧也能被正确销毁。

高级特性：coroutine_handle::from_address()

除了上面介绍的成员函数外，coroutine_handle 还提供了一个静态成员函数 from_address()，允许我们从一个内存地址创建一个 coroutine_handle。这个函数通常用于底层框架开发，例如自定义的调度器或内存管理器。但是要非常小心的使用这个函数，因为如果提供的地址不是一个有效的协程帧的起始地址，会导致未定义行为。

#include <iostream>
#include <coroutine>
 
struct MyCoroutine {
    struct promise_type {
        int value;
        MyCoroutine get_return_object() {
            return {std::coroutine_handle<promise_type>::from_promise(*this)};
        }
        std::suspend_never initial_suspend() { return {}; }
        std::suspend_never final_suspend() noexcept { return {}; }
        void unhandled_exception() {}
    };
    std::coroutine_handle<promise_type> handle;
};
 
MyCoroutine simpleCoroutine() {
    co_return;
}
 
int main() {
    MyCoroutine coro = simpleCoroutine();
    //  极其危险的操作！仅用于演示，实际应用中必须确保地址的有效性
    std::coroutine_handle<MyCoroutine::promise_type> handle = std::coroutine_handle<MyCoroutine::promise_type>::from_address(coro.handle.address());
 
    if (handle) {
        std::cout << "Handle created from address" << std::endl;
    } else {
        std::cout << "Failed to create handle from address" << std::endl;
    }
 
    coro.handle.destroy();
    return 0;
}

警告： from_address() 是一个非常底层的函数，使用不当会导致严重的错误。只有当你完全理解协程的内存布局和生命周期管理时，才能安全地使用这个函数。

异常处理与 coroutine_handle

协程中的异常处理是一个复杂但至关重要的话题。当协程抛出未处理的异常时，会调用 Promise 的 unhandled_exception() 方法。默认情况下，这个方法会调用 std::terminate() 终止程序。但是，我们可以自定义 unhandled_exception() 方法来处理异常，例如记录日志、清理资源或将异常传递给调用者。

#include <iostream>
#include <coroutine>
#include <exception>
 
struct MyCoroutine {
    struct promise_type {
        int value;
        MyCoroutine get_return_object() {
            return {std::coroutine_handle<promise_type>::from_promise(*this)};
        }
        std::suspend_never initial_suspend() { return {}; }
        std::suspend_never final_suspend() noexcept { return {}; }
        void unhandled_exception() {
            std::cerr << "Unhandled exception in coroutine!" << std::endl;
            //  可以在这里进行一些清理操作
            std::terminate(); //  或者选择其他处理方式
        }
    };
    std::coroutine_handle<promise_type> handle;
};
 
MyCoroutine throwingCoroutine() {
    throw std::runtime_error("Something went wrong!");
    co_return;
}
 
int main() {
    MyCoroutine coro = throwingCoroutine();
    //  异常会在协程创建时抛出，并调用 promise 的 unhandled_exception
    coro.handle.destroy();
    return 0;
}

coroutine_handle 在异常处理中扮演着重要的角色，它允许我们在协程外部观察和控制协程的异常状态。例如，我们可以通过 coroutine_handle::promise() 获取 Promise 对象，并检查是否有异常发生。

总结

coroutine_handle 是 C++ 协程的核心组成部分，它提供了一种从协程外部控制协程执行和管理协程状态的机制。理解 coroutine_handle 的作用、成员函数和生命周期管理对于编写高效、可靠的协程程序至关重要。希望本文能够帮助你更深入地理解 coroutine_handle，并在实际开发中灵活运用。

掌握 coroutine_handle，你就能像一个熟练的灵魂摆渡者一样，自由地穿梭于协程的世界，掌控协程的命运。

协程掌控者 C++协程coroutine_handle

评论点评

打赏赞助
sponsor

感谢您的支持让我们更好的前行

分享

QRcode

https://www.webkt.com/article/9313