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
Definido en el encabezado <stop_token>
class stop_source ;
(desde C++20)

La clase stop_source proporciona los medios para emitir una solicitud de parada, como para la cancelación de std::jthread . Una solicitud de parada realizada para un objeto stop_source es visible para todas las stop_source s y std::stop_token s del mismo estado de parada asociado; cualquier std::stop_callback (s) registrado para std::stop_token (s) asociado(s) será invocado, y cualquier objeto std::condition_variable_any que esté esperando en std::stop_token (s) asociado(s) será despertado.

Una vez que se solicita una parada, no puede ser retirada. Las solicitudes de parada adicionales no tienen efecto.

Contenidos

Funciones miembro

construye un nuevo objeto stop_source
(función miembro pública)
destruye el objeto stop_source
(función miembro pública)
asigna el objeto stop_source
(función miembro pública)
Modificadores
realiza una solicitud de parada para el estado de parada asociado, si existe
(función miembro pública)
intercambia dos objetos stop_source
(función miembro pública)
Observadores
devuelve un stop_token para el estado de parada asociado
(función miembro pública)
verifica si se ha solicitado la parada para el estado de parada asociado
(función miembro pública)
verifica si se puede solicitar la parada para el estado de parada asociado
(función miembro pública)

Funciones no miembro

(C++20)
compara dos objetos std::stop_source
(función)
(C++20)
especializa el algoritmo std::swap
(función)

Etiquetas auxiliares

(C++20)
una etiqueta utilizada para stop_source para indicar que no hay un estado de parada asociado al construir
(etiqueta)

Notas

Para los propósitos de std::jthread cancelación, el objeto stop_source debe obtenerse del objeto std::jthread utilizando get_stop_source() ; o la parada debe solicitarse directamente desde el objeto std::jthread utilizando request_stop() . Esto utilizará entonces el mismo estado de parada asociado que se pasó al argumento de función invocado del std::jthread (es decir, la función que se está ejecutando en su hilo).

Para otros usos, sin embargo, un stop_source puede construirse por separado usando el constructor predeterminado, que crea un nuevo estado de parada.

Macro de prueba de características Valor Std Característica
__cpp_lib_jthread 201911L (C++20) Stop token y joining thread

Ejemplo

Ejecutar este código 
#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");
    };
    // Fuente común
    std::stop_source stop_source;
    print(stop_source);
    // Crear hilos de trabajo
    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("Solicitar parada");
    stop_source.request_stop();
    print(stop_source);
    // Nota: el destructor de jthreads llamará a join así que no se necesitan llamadas explícitas
}

Salida posible: 

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
Solicitar parada
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