Namespaces
Variants

std:: stop_callback

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
(C++20)
(C++26)
(C++26)
(C++20)
(C++26)
stop_callback
(C++20)
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_callback
Défini dans l'en-tête <stop_token>
template < class Callback >
class stop_callback ;
(depuis C++20)

La classe template stop_callback fournit un type d'objet RAII qui enregistre une fonction de rappel pour un std::stop_token associé, de telle sorte que la fonction de rappel sera invoquée lorsque le std::stop_token associé verra sa std::stop_source correspondante recevoir une demande d'arrêt.

Les fonctions de rappel enregistrées via le constructeur de stop_callback sont appelées soit dans le même thread qui invoque avec succès request_stop ( ) pour un std::stop_source du std::stop_token associé au stop_callback ; soit si l'arrêt a déjà été demandé avant l'enregistrement par le constructeur, alors le rappel est invoqué dans le thread construisant le stop_callback .

Plus d'un stop_callback peut être créé pour le même std::stop_token , depuis le même thread ou différents threads simultanément. Aucune garantie n'est fournie quant à l'ordre dans lequel ils seront exécutés, mais ils seront invoqués de manière synchrone ; à l'exception des stop_callback construits après que l'arrêt a déjà été demandé pour le std::stop_token , comme décrit précédemment.

Si un appel d'un callback se termine par une exception alors std::terminate est appelé.

std::stop_callback n'est pas CopyConstructible , CopyAssignable , MoveConstructible , ni MoveAssignable .

Le paramètre de modèle Callback doit être à la fois invocable et destructible . Toute valeur de retour est ignorée.

Table des matières

Types membres

Type Définition
callback_type Callback

Fonctions membres

construit un nouvel objet stop_callback
(fonction membre publique)
détruit l'objet stop_callback
(fonction membre publique)
operator=
[deleted]
stop_callback n'est pas assignable
(fonction membre publique)

Guides de déduction

Exemple

Exécuter ce code 
#include <chrono>
#include <condition_variable>
#include <iostream>
#include <mutex>
#include <sstream>
#include <thread>
using namespace std::chrono_literals;
// Utiliser une classe helper pour un flux std::cout atomique.
class Writer
{
    std::ostringstream buffer;
public:
    ~Writer()
    {
        std::cout << buffer.str();
    }
    Writer& operator<<(auto input)
    {
        buffer << input;
        return *this;
    }
};
int main()
{
    // Un thread worker.
    // Il attendra jusqu'à ce qu'on lui demande de s'arrêter.
    std::jthread worker([] (std::stop_token stoken)
    {
        Writer() << "Worker thread's id: " << std::this_thread::get_id() << '\n';
        std::mutex mutex;
        std::unique_lock lock(mutex);
        std::condition_variable_any().wait(lock, stoken,
            [&stoken] { return stoken.stop_requested(); });
    });
    // Enregistrer un callback d'arrêt sur le thread worker.
    std::stop_callback callback(worker.get_stop_token(), []
    {
        Writer() << "Stop callback executed by thread: "
            << std::this_thread::get_id() << '\n';
    });
    // Les objets stop_callback peuvent être détruits prématurément pour empêcher l'exécution.
    {
        std::stop_callback scoped_callback(worker.get_stop_token(), []
        {
            // Ceci ne sera pas exécuté.
            Writer() << "Scoped stop callback executed by thread: "
                << std::this_thread::get_id() << '\n';
        });
    }
    // Démontrer quel thread exécute le stop_callback et quand.
    // Définir une fonction stopper.
    auto stopper_func = [&worker]
    {
        if (worker.request_stop())
            Writer() << "Stop request executed by thread: "
                << std::this_thread::get_id() << '\n';
        else
            Writer() << "Stop request not executed by thread: "
                << std::this_thread::get_id() << '\n';
    };
    // Laisser plusieurs threads concourir pour arrêter le thread worker.
    std::jthread stopper1(stopper_func);
    std::jthread stopper2(stopper_func);
    stopper1.join();
    stopper2.join();
    // Après qu'un arrêt a déjà été demandé,
    // un nouveau stop_callback s'exécute immédiatement.
    Writer() << "Main thread: " << std::this_thread::get_id() << '\n';
    std::stop_callback callback_after_stop(worker.get_stop_token(), []
    {
        Writer() << "Stop callback executed by thread: "
            << std::this_thread::get_id() << '\n';
    });
}

Sortie possible : 

Worker thread's id: 140460265039616
Stop callback executed by thread: 140460256646912
Stop request executed by thread: 140460256646912
Stop request not executed by thread: 140460248254208
Main thread: 140460265043776
Stop callback executed by thread: 140460265043776