CKTIS / C++
std::jthread: unión automática y detención cooperativa
std::jthread gestiona un hilo y, cuando se destruye un objeto que todavía puede unirse, solicita su detención y después espera a que termine. std::jthread::request_stop no interrumpe la ejecución por la fuerza: el hilo debe cooperar, por ejemplo comprobando un std::stop_token.
Versión: C++23; repository compiler flag, production runtime not attested
Sintaxis
#include <thread>
#include <stop_token>
std::jthread worker([](std::stop_token token) {
// Cooperatively observe token.stop_requested().
});
bool first_request = worker.request_stop();std::jthread, declarado en <thread>, es un objeto movible y no copiable que posee un hilo. El constructor comprueba si la llamada es válida usando los tipos del objeto invocable y de los argumentos tras aplicar std::decay_t, no las expresiones proporcionadas originalmente. Si std::is_invocable_v<std::decay_t<F>, std::stop_token, std::decay_t<Args>...> es true (donde F y Args... son los tipos deducidos del objeto invocable y de los argumentos), el constructor elige la llamada con std::stop_token como primer argumento. De lo contrario, elige la llamada sin token, que debe ser válida para los mismos tipos transformados. Recibir un token, por sí solo, no implementa la detención.
std::jthread::request_stop() tiene la firma bool request_stop() noexcept. Devuelve true cuando esta llamada registra por primera vez una solicitud en el estado de detención compartido; las solicitudes posteriores devuelven false. También devuelve false si no hay un estado de detención. El resultado no confirma que el hilo haya terminado. Los callbacks registrados para responder a una solicitud de detención se ejecutan de forma síncrona durante la primera solicitud que devuelve true.
Si joinable() devuelve true, el destructor llama a request_stop() y, después, a join(). Por tanto, a diferencia de std::thread, no hace falta una unión manual antes de salir normalmente del ámbito. Sin embargo, esto no es una cancelación forzada: ignorar el token o permanecer en una operación bloqueante puede retrasar la finalización indefinidamente. Las referencias capturadas deben seguir siendo válidas hasta que termine el hilo.
En el ejemplo, la primera solicitud produce true y la segunda false. El destructor espera a que termine el hilo antes de leer observed, por lo que este bool normal no necesita operaciones atómicas aquí. El bucle con yield() es solo una pequeña demostración de espera activa, no un patrón de espera eficiente. El modo del repositorio es C++23; esto no acredita la compatibilidad del entorno de ejecución en producción. La referencia proporcionada lleva a un borrador de norma en evolución, no a una edición C++23 fija.
Ejemplos
#include <iostream>
#include <stop_token>
#include <thread>
int main() {
bool observed = false;
bool first = false;
bool second = false;
{
std::jthread worker([&observed](std::stop_token token) {
while (!token.stop_requested()) {
std::this_thread::yield();
}
observed = true;
});
first = worker.request_stop();
second = worker.request_stop();
}
std::cout << std::boolalpha
<< first << ' ' << second << ' ' << observed << '\n';
}
Resultado
true false true
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.
Fuentes
- C++ working draft — Concurrency support library [thread]
- C++ working draft — Constructors, move, and assignment [thread.jthread.cons]
- C++ working draft — Stop token handling [thread.jthread.stop]
- C++ working draft — Member functions [stopsource.mem]
- C++ working draft — Stop token concepts [stoptoken.concepts]
- C++ working draft — Member functions [thread.jthread.mem] (unofficial HTML rendering)