std::jthread:: request_stop

Sendet eine Stoppanforderung an den internen Stoppzustand, falls noch keine Stoppanforderung gestellt wurde.

Die Entscheidung wird atomar getroffen, und falls ein Stopp angefordert wurde, wird der Stopp-Zustand atomar aktualisiert, um Wettlaufsituationen zu vermeiden, sodass:

• stop_requested ( ) und stop_possible ( ) können gleichzeitig auf anderen std::stop_token s und std::stop_source s desselben gemeinsamen Stop-Zustands aufgerufen werden.
• request_stop ( ) kann gleichzeitig von mehreren Threads auf demselben jthread -Objekt oder auf anderen std::stop_source -Objekten mit demselben Stop-Zustand aufgerufen werden, und nur einer wird tatsächlich die Stop-Anforderung ausführen.

Siehe jedoch den Abschnitt "Notes".

Parameter

(keine)

Rückgabewert

true wenn dieser Aufruf eine Stoppanfrage ausgelöst hat, andernfalls false .

Nachbedingungen

Für einen std::stop_token , der durch get_stop_token ( ) abgerufen wird, oder eine std::stop_source , die durch get_stop_source ( ) abgerufen wird, ist stop_requested ( ) true .

Hinweise

Wenn die request_stop ( ) tatsächlich eine Stoppanforderung ausgibt (d.h. true zurückgibt), dann werden alle std::stop_callbacks , die für denselben assoziierten Stop-Zustand registriert sind, synchron auf demselben Thread aufgerufen, auf dem request_stop ( ) ausgeführt wird. Wenn ein Aufruf eines Callbacks durch eine Exception beendet wird, wird std::terminate aufgerufen.

Wenn bereits eine Stoppanforderung gestellt wurde, gibt diese Funktion false zurück. Es gibt jedoch keine Garantie, dass ein anderer Thread oder ein std::stop_source -Objekt, das gerade (erfolgreich) eine Stoppanforderung für denselben Stoppzustand gestellt hat, sich nicht noch mitten im Aufruf einer std::stop_callback -Funktion befindet.

Falls die request_stop ( ) tatsächlich eine Stoppanforderung ausgibt (d.h. true zurückgibt), dann werden alle Bedingungsvariablen des Basistyps std::condition_variable_any , die mit einem unterbrechbaren Wait für std::stop_token s registriert sind, die dem internen Stop-Zustand des jthread zugeordnet sind, aufgeweckt.

Beispiel

#include <chrono>
#include <condition_variable>
#include <iostream>
#include <mutex>
#include <thread>
using namespace std::chrono_literals;
// Hilfsfunktion zur schnellen Anzeige, welcher Thread was ausgegeben hat
void print(auto txt)
{
    std::cout << std::this_thread::get_id() << ' ' << txt;
}
int main()
{
    // Ein schläfriger Worker-Thread
    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");
            }
        });
    // Ein wartender Worker-Thread
    // Die Bedingungsvariable wird durch die Stop-Anforderung aufgeweckt.
    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;
        });
    // Diesen Thread schlafen legen, um den Threads Zeit zum Ausführen zu geben
    std::this_thread::sleep_for(400ms);
    // std::jthread::request_stop() kann explizit aufgerufen werden:
    print("Requesting stop of sleepy worker\n");
    sleepy_worker.request_stop();
    sleepy_worker.join();
    print("Sleepy worker joined\n");
    // Oder automatisch mittels RAII:
    // Der Destruktor von waiting_worker ruft request_stop() auf
    // und joined den Thread automatisch.
}

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