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
Definiert in Header <stop_token>
class stop_source ;
(seit C++20)

Die stop_source -Klasse bietet die Möglichkeit, eine Stoppanforderung auszugeben, wie beispielsweise für die std::jthread -Abbruch. Eine Stoppanforderung, die für ein stop_source -Objekt gestellt wird, ist für alle stop_source s und std::stop_token s desselben assoziierten Stoppzustands sichtbar; alle std::stop_callback (s), die für assoziierte std::stop_token (s) registriert sind, werden aufgerufen, und alle std::condition_variable_any -Objekte, die auf assoziierte std::stop_token (s) warten, werden aufgeweckt.

Sobald ein Stopp angefordert wurde, kann dieser nicht mehr zurückgezogen werden. Zusätzliche Stopp-Anfragen haben keine Auswirkung.

Inhaltsverzeichnis

Memberfunktionen

konstruiert neues stop_source Objekt
(public member function)
zerstört das stop_source Objekt
(public member function)
weist das stop_source Objekt zu
(public member function)
Modifikatoren
stellt eine Stoppanfrage für den assoziierten Stoppzustand, falls vorhanden
(public member function)
tauscht zwei stop_source Objekte
(public member function)
Beobachter
gibt einen stop_token für den assoziierten Stoppzustand zurück
(public member function)
prüft, ob für den assoziierten Stoppzustand ein Stopp angefordert wurde
(public member function)
prüft, ob der assoziierte Stoppzustand gestoppt werden kann
(public member function)

Nicht-Member-Funktionen

(C++20)
vergleicht zwei std::stop_source Objekte
(Funktion)
(C++20)
spezialisiert den std::swap Algorithmus
(Funktion)

Hilfs-Tags

(C++20)
ein Tag, der für stop_source verwendet wird, um anzuzeigen, dass beim Konstruieren kein zugehöriger Stop-Zustand vorhanden ist
(Tag)

Hinweise

Für die Zwecke des std::jthread Abbruchs sollte das stop_source Objekt aus dem std::jthread Objekt mittels get_stop_source() abgerufen werden; oder der Stop sollte direkt vom std::jthread Objekt mittels request_stop() angefordert werden. Dies verwendet dann denselben assoziierten Stop-Zustand wie jener, der in das aufgerufene Funktionsargument des std::jthread übergeben wird (d.h. die Funktion, die in seinem Thread ausgeführt wird).

Für andere Anwendungsfälle kann jedoch eine stop_source separat mit dem Standardkonstruktor erstellt werden, die einen neuen Stop-Zustand erzeugt.

Feature-Test Makro Wert Std Feature
__cpp_lib_jthread 201911L (C++20) Stop-Token und Joining-Thread

Beispiel

Diesen Code ausführen 
#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");
    };
    // Gemeinsame Quelle
    std::stop_source stop_source;
    print(stop_source);
    // Worker-Threads erstellen
    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("Stop anfordern");
    stop_source.request_stop();
    print(stop_source);
    // Hinweis: Destruktor von jthreads ruft join auf, daher keine expliziten Aufrufe erforderlich
}

Mögliche Ausgabe: 

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
Stop anfordern
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