Namespaces
Variants

std:: stop_source

From cppreference.net
C++
Concurrency support library
Threads
(C++11)
(C++20)
(C++17) (C++17)
this_thread namespace
(C++11)
(C++11)
Cooperative cancellation
Mutual exclusion
Generic lock management
Condition variables
(C++11)
(C++11)
(C++11)
(C++11)
Semaphores
(C++20) (C++20)
Latches and Barriers
(C++20)
(C++20)
Futures
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Safe reclamation
Hazard pointers
(C++26)
(C++26)
(C++26)
Atomic types
(C++11)
(C++20)
(C++11)
Initialization of atomic types
(C++11) (deprecated in C++20)
(C++11) (deprecated in C++20)
(C++11)
Memory ordering
(C++11)
(C++11) (deprecated in C++26)
(C++11)
(C++11)
Free functions for atomic operations
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11) (C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++26) (C++26)
(C++26) (C++26)
(C++11)
(C++20) (C++20)
(C++20)
(C++20)
Free functions for atomic flags
(C++11) (C++11)
(C++11) (C++11)
(C++20) (C++20)
(C++20) (C++20)
(C++20)
(C++20)
std::stop_source
Défini dans l'en-tête <stop_token>
class stop_source ;
(depuis C++20)

La classe stop_source fournit les moyens d'émettre une requête d'arrêt, comme pour l'annulation de std::jthread . Une requête d'arrêt effectuée pour un objet stop_source est visible par tous les stop_source et std::stop_token partageant le même état d'arrêt associé ; tout std::stop_callback enregistré pour les std::stop_token associés sera invoqué, et tout objet std::condition_variable_any en attente sur les std::stop_token associés sera réveillé.

Une fois qu'un arrêt est demandé, il ne peut pas être retiré. Les demandes d'arrêt supplémentaires n'ont aucun effet.

Table des matières

Fonctions membres

construit un nouvel objet stop_source
(fonction membre publique)
détruit l'objet stop_source
(fonction membre publique)
assigne l'objet stop_source
(fonction membre publique)
Modificateurs
effectue une demande d'arrêt pour l'état d'arrêt associé, s'il existe
(fonction membre publique)
échange deux objets stop_source
(fonction membre publique)
Observateurs
retourne un stop_token pour l'état d'arrêt associé
(fonction membre publique)
vérifie si une demande d'arrêt a été effectuée pour l'état d'arrêt associé
(fonction membre publique)
vérifie si l'état d'arrêt associé peut recevoir une demande d'arrêt
(fonction membre publique)

Fonctions non membres

(C++20)
compare deux objets std::stop_source
(fonction)
(C++20)
spécialise l'algorithme std::swap
(fonction)

Balises d'assistance

(C++20)
une balise utilisée pour stop_source pour indiquer l'absence d'état d'arrêt associé lors de la construction
(balise)

Notes

Aux fins d'annulation de std::jthread , l'objet stop_source doit être récupéré depuis l'objet std::jthread en utilisant get_stop_source() ; ou l'arrêt doit être demandé directement depuis l'objet std::jthread en utilisant request_stop() . Cela utilisera alors le même état d'arrêt associé que celui passé en argument à la fonction invoquée du std::jthread (c'est-à-dire la fonction exécutée sur son thread).

Pour d'autres utilisations cependant, un stop_source peut être construit séparément en utilisant le constructeur par défaut, qui crée un nouvel état d'arrêt.

Macro de test de fonctionnalité Valeur Std Fonctionnalité
__cpp_lib_jthread 201911L (C++20) Stop token et joining thread

Exemple

Exécuter ce code 
#include <chrono>
#include <iostream>
#include <stop_token>
#include <thread>
using namespace std::chrono_literals;
void worker_fun(int id, std::stop_token stoken)
{ 
    for (int i = 10; i; --i)
    {
        std::this_thread::sleep_for(300ms);
        if (stoken.stop_requested())
        {
            std::printf("  worker%d is requested to stop\n", id);
            return;
        }
        std::printf("  worker%d goes back to sleep\n", id);
    }
}
int main()
{
    std::jthread threads[4];
    std::cout << std::boolalpha;
    auto print = [](const std::stop_source& source)
    {
        std::printf("stop_source stop_possible = %s, stop_requested = %s\n",
                    source.stop_possible() ? "true" : "false",
                    source.stop_requested() ? "true" : "false");
    };
    // Source commune
    std::stop_source stop_source;
    print(stop_source);
    // Créer les threads de travail
    for (int i = 0; i < 4; ++i)
        threads[i] = std::jthread(worker_fun, i + 1, stop_source.get_token());
    std::this_thread::sleep_for(500ms);
    std::puts("Demander l'arrêt");
    stop_source.request_stop();
    print(stop_source);
    // Note : le destructeur de jthreads appellera join donc pas besoin d'appels explicites
}

Sortie possible : 

stop_source stop_possible = true, stop_requested = false
  worker2 goes back to sleep
  worker3 goes back to sleep
  worker1 goes back to sleep
  worker4 goes back to sleep
Demander l'arrêt
stop_source stop_possible = true, stop_requested = true
  worker3 is requested to stop
  worker1 is requested to stop
  worker2 is requested to stop
  worker4 is requested to stop