Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C++

std::jthread — jonction automatique et arrêt coopératif

std::jthread gère un thread et, lorsqu’un objet pouvant être joint est détruit, demande son arrêt puis attend sa fin. std::jthread::request_stop n’interrompt pas l’exécution de force : le thread doit coopérer, par exemple en vérifiant un std::stop_token.

Version : C++23; repository compiler flag, production runtime not attested

Syntaxe

#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, déclaré dans <thread>, est un propriétaire de thread déplaçable et non copiable. Le constructeur vérifie si l’appel est valide à partir des types de l’objet appelable et des arguments après transformation par std::decay_t, et non à partir des expressions fournies à l’origine. Si std::is_invocable_v<std::decay_t<F>, std::stop_token, std::decay_t<Args>...> vaut true (où F et Args... sont les types déduits de l’objet appelable et des arguments), le constructeur choisit l’appel avec std::stop_token comme premier argument. Sinon, il choisit l’appel sans token, qui doit être valide pour les mêmes types transformés. Recevoir un token ne suffit pas, à lui seul, à mettre en œuvre l’arrêt.

std::jthread::request_stop() a pour signature bool request_stop() noexcept. La fonction renvoie true lorsque cet appel inscrit pour la première fois une demande dans l’état d’arrêt partagé ; les demandes suivantes renvoient false. Elle renvoie également false en l’absence d’état d’arrêt. Le résultat ne confirme pas que le thread a terminé. Les fonctions de rappel d’arrêt enregistrées s’exécutent de manière synchrone lors de la première demande réussie.

Si joinable() renvoie true, le destructeur appelle request_stop(), puis join(). Contrairement à std::thread, il n’est donc pas nécessaire d’effectuer une jonction manuelle avant de quitter normalement la portée. Il ne s’agit pas d’une annulation forcée : ignorer le token ou rester bloqué dans une opération peut retarder la fin indéfiniment. Les références capturées doivent rester valides jusqu’à la fin du thread.

Dans l’exemple, la première demande renvoie true et la seconde false. Le destructeur attend la fin du thread avant la lecture de observed ; ce bool ordinaire ne nécessite donc pas d’opérations atomiques ici. La boucle yield() est uniquement une petite démonstration d’attente active, et non une méthode d’attente efficace. Le mode du dépôt est C++23 ; cela ne garantit pas la prise en charge à l’exécution en production. La référence fournie pointe vers un projet de norme en évolution, et non vers une édition C++23 figée.

Exemples

#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';
}

Résultat

true false true

Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.

Sources