std::jthread:: request_stop

Émet une requête d'arrêt vers l'état d'arrêt interne, si cela n'a pas déjà été demandé.

La détermination est effectuée de manière atomique, et si l'arrêt a été demandé, l'état d'arrêt est mis à jour atomiquement pour éviter les conditions de concurrence, de telle sorte que :

• stop_requested ( ) et stop_possible ( ) peuvent être invoqués simultanément sur d'autres std::stop_token et std::stop_source partageant le même état d'arrêt.
• request_stop ( ) peut être invoqué simultanément depuis plusieurs threads sur le même objet jthread ou sur d'autres std::stop_source associés au même état d'arrêt, et un seul exécutera réellement la demande d'arrêt.

Cependant, consultez la section Notes.

Paramètres

(aucun)

Valeur de retour

true si cet appel a effectué une demande d'arrêt, sinon false .

Postconditions

Pour un std::stop_token obtenu par get_stop_token ( ) ou un std::stop_source obtenu par get_stop_source ( ) , stop_requested ( ) est true .

Notes

Si la request_stop ( ) émet effectivement une demande d'arrêt (c'est-à-dire retourne true ), alors tous les std::stop_callbacks enregistrés pour le même état d'arrêt associé seront invoqués de manière synchrone, sur le même thread request_stop ( ) est émis. Si une invocation d'un callback se termine par une exception, std::terminate est appelée.

Si une demande d'arrêt a déjà été effectuée, cette fonction retourne false . Cependant, il n'y a aucune garantie qu'un autre thread ou un objet std::stop_source qui vient juste (avec succès) de demander l'arrêt pour le même état d'arrêt ne soit pas encore en train d'invoquer une fonction std::stop_callback .

Si la request_stop ( ) émet effectivement une demande d'arrêt (c'est-à-dire retourne true ), alors toutes les variables de condition de type de base std::condition_variable_any enregistrées avec une attente interruptible pour les std::stop_token associés à l'état d'arrêt interne du jthread seront réveillées.

Exemple

#include <chrono>
#include <condition_variable>
#include <iostream>
#include <mutex>
#include <thread>
using namespace std::chrono_literals;
// Fonction utilitaire pour afficher rapidement quel thread a imprimé quoi
void print(auto txt)
{
    std::cout << std::this_thread::get_id() << ' ' << txt;
}
int main()
{
    // Un thread travailleur endormi
    std::jthread sleepy_worker(
        [](std::stop_token stoken)
        {
            for (int i = 10; i; --i)
            {
                std::this_thread::sleep_for(300ms);
                if (stoken.stop_requested())
                {
                    print("Sleepy worker is requested to stop\n");
                    return;
                }
                print("Sleepy worker goes back to sleep\n");
            }
        });
    // Un thread travailleur en attente
    // La variable de condition sera réveillée par la demande d'arrêt.
    std::jthread waiting_worker(
        [](std::stop_token stoken)
        {
            std::mutex mutex;
            std::unique_lock lock(mutex);
            std::condition_variable_any().wait(lock, stoken, []{ return false; });
            print("Waiting worker is requested to stop\n");
            return;
        });
    // Mettre ce thread en sommeil pour donner aux threads le temps de tourner
    std::this_thread::sleep_for(400ms);
    // std::jthread::request_stop() peut être appelé explicitement :
    print("Requesting stop of sleepy worker\n");
    sleepy_worker.request_stop();
    sleepy_worker.join();
    print("Sleepy worker joined\n");
    // Ou automatiquement en utilisant RAII :
    // Le destructeur de waiting_worker appellera request_stop()
    // et joindra le thread automatiquement.
}

140287602706176 Sleepy worker goes back to sleep
140287623300928 Requesting stop of sleepy worker
140287602706176 Sleepy worker is requested to stop
140287623300928 Sleepy worker joined
140287594313472 Waiting worker is requested to stop