std::jthrea..._stop_source(3)

Manual-page check ✅: this is std::jthrea..._stop_source(3) from the C++ Standard Libary manual — yes, that’s the spelling up top, don’t come for me 😭 — and the main-character function is std::jthread::get_stop_source. C++20 girlies, this one’s for you ✨

💖 NAME 💖

std::jthread::get_stop_source - std::jthread::get_stop_source — that’s the whole name, and honestly it’s giving “I said what I said” 💅

✨ Synopsis ✨

std::stop_source get_stop_source() noexcept;  (since C++20)

okay so this returns a std::stop_source associated with the same shared stop-state as held internally by the jthread object. Like, the jthread has its little stop-state situation, and this hands you a source that’s tied to that exact same shared stop-state. no cap 🫶

🌸 Parameters 🌸

(none) — literally zero parameters, bestie. not a one. the void. 💀

🎀 Return value 🎀

A value of type std::stop_source associated with the stop-state held internally by the jthread object. that’s the return value, and it ate ✨

💻 Example 💻

       // Run this code

        #include <chrono>
        #include <condition_variable>
        #include <iostream>
        #include <mutex>
        #include <string_view>
        #include <thread>

        using namespace std::chrono_literals;

        int main()
        {
            std::cout << std::boolalpha;
            auto print = [](std::string_view name, const std::stop_source&
       source)
            {
                std::cout << name << ": stop_possible = " <<
       source.stop_possible();
                std::cout << ", stop_requested = " << source.stop_requested()
       << '\n';
            };

            // A worker thread
            auto worker = std::jthread([](std::stop_token stoken)
            {
                for (int i = 10; i; --i)
                {
                    std::this_thread::sleep_for(300ms);
                    if (stoken.stop_requested())
                    {
                        std::cout << "  Sleepy worker is requested to stop\n";
                        return;
                    }
                    std::cout << "  Sleepy worker goes back to sleep\n";
                }
            });

            std::stop_source stop_source = worker.get_stop_source();
            print("stop_source", stop_source);

            std::cout << "\nPass source to other thread:\n";
            auto stopper = std::thread(
                [](std::stop_source source)
                {
                    std::this_thread::sleep_for(500ms);
                    std::cout << "Request stop for worker via source\n";
                    source.request_stop();
                },
                stop_source);
            stopper.join();
            std::this_thread::sleep_for(200ms);
            std::cout << '\n';

            print("stop_source", stop_source);
        }

🌈 Possible output 🌈

        stop_source: stop_possible = true, stop_requested = false

        Pass source to other thread:
          Sleepy worker goes back to sleep
        Request stop for worker via source
          Sleepy worker is requested to stop

        stop_source: stop_possible = true, stop_requested = true

okay bye bestie 🫶 — footer vibes: source http://cppreference.com, date 2024.06.10, page std::jthrea..._stop_source(3). mwah 💋