CKTIS / C++
Corutinas
Una corutina puede suspender la ejecución y reanudarla más tarde, conservando el estado que necesita. Las palabras clave co_await, co_yield y co_return colaboran con un tipo promise y un handle de corutina; no inician automáticamente un hilo ni un planificador.
Versión: C++23; repository compiler flag, production runtime not attested
Sintaxis
co_await expression; co_yield expression; co_return [expression];Una corutina es una función cuyo cuerpo contiene co_await, co_yield o co_return. Al suspenderse, conserva el estado necesario para continuar. El control puede volver a quien la llamó o la reanudó, pero si await_suspend() del awaiter devuelve un handle de otra corutina, el control pasa directamente a esa corutina. Esto no implica ejecución paralela automática: una corutina por sí sola no crea ni un hilo ni un planificador.
co_await utiliza el protocolo awaiter: await_ready() comprueba si el resultado está listo, await_suspend() gestiona la suspensión y await_resume() proporciona el resultado. No todos los usos de co_await dejan realmente suspendida la corutina. co_yield value espera el resultado de promise.yield_value(value) sin aplicar await_transform del objeto promise. En cambio, si se escribe explícitamente co_await promise.yield_value(value), se usa await_transform si el tipo promise lo proporciona. Por tanto, la sustitución puede cambiar el comportamiento o provocar un error de compilación. co_return termina el cuerpo de la corutina, en lugar de pasar un valor directamente a quien la llamó.
El tipo promise, disponible normalmente como promise_type del tipo de retorno, controla, entre otras cosas, el objeto de resultado, la suspensión inicial y final, la finalización y el tratamiento de excepciones. <coroutine> proporciona std::coroutine_handle y std::suspend_always. Un handle no gestiona por sí solo el ciclo de vida del estado: la responsabilidad de destruirlo debe ser explícita.
En el ejemplo, Task es un propietario que no se puede copiar ni mover. initial_suspend() retrasa la ejecución del cuerpo, y final_suspend() conserva el estado para que lo destruya el destructor. El std::suspend_always que se usa en el ejemplo no transfiere el control directamente a otra corutina. Dos reanudaciones imprimen 1 y 2; la tercera no hace nada debido a done(). Reanudar una corutina terminada o no suspendida provoca un comportamiento indefinido. Si el estado de la corutina ya se ha destruido, intentar reanudarla mediante un handle a ese estado también provoca un comportamiento indefinido. En cambio, restablecer ese handle asignándole nullptr es una operación bien definida. Los objetos a los que se accede mediante referencias deben seguir vivos el tiempo suficiente.
Esta entrada se refiere a C++23; la opción del compilador del repositorio no acredita compatibilidad con el entorno de ejecución de producción. El documento proporcionado es un borrador de trabajo en evolución, no una edición definitiva de C++23. El ejemplo requiere verificación local y llama deliberadamente a std::terminate() si se produce una excepción no controlada.
Ejemplos
#include <coroutine>
#include <exception>
#include <iostream>
class Task {
public:
struct promise_type {
Task get_return_object() {
return Task{std::coroutine_handle<promise_type>::from_promise(*this)};
}
std::suspend_always initial_suspend() noexcept { return {}; }
std::suspend_always final_suspend() noexcept { return {}; }
void return_void() noexcept {}
void unhandled_exception() noexcept { std::terminate(); }
};
using Handle = std::coroutine_handle<promise_type>;
explicit Task(Handle handle) noexcept : handle_(handle) {}
Task(const Task&) = delete;
Task& operator=(const Task&) = delete;
~Task() { handle_.destroy(); }
void resume() {
if (!handle_.done()) {
handle_.resume();
}
}
private:
Handle handle_;
};
Task steps() {
std::cout << "1\n";
co_await std::suspend_always{};
std::cout << "2\n";
co_return;
}
int main() {
auto task = steps();
task.resume();
task.resume();
task.resume();
}
Resultado
1 2
El código mostrado y el resultado declarado se verificaron en un entorno aislado mediante el método registrado en la evidencia de verificación de esta versión exacta.