Cooperative Interruption of a Thread in C++20: Callbacks

// invokeCallback.cpp

#include <chrono>
#include <iostream>
#include <thread>
#include <vector>

using namespace::std::literals;

auto func = [](std::stop_token stoken) {                             // (1)
        int counter{0};
        auto thread_id = std::this_thread::get_id();
        std::stop_callback callBack(stoken, [&counter, thread_id] {  // (2)
            std::cout << "Thread id: " << thread_id 
                      << "; counter: " << counter << '\n';
        });
        while (counter < 10) {
            std::this_thread::sleep_for(0.2s);
            ++counter;
        }
    };

int main() {
    
    std::cout << '\n';
    
    std::vector<std::jthread> vecThreads(10);
    for(auto& thr: vecThreads) thr = std::jthread(func);
    
    std::this_thread::sleep_for(1s);                              // (3)
    
    for(auto& thr: vecThreads) thr.request_stop();                // (4)

    std::cout << '\n';
    
}

// invokeCallbacks.cpp

#include <chrono>
#include <iostream>
#include <thread>

using namespace std::literals;

void func(std::stop_token stopToken) {
    std::this_thread::sleep_for(100ms);
    for (int i = 0; i <= 9; ++i) {
       std::stop_callback cb(stopToken, [i] { std::cout << i; });
    }
    std::cout << '\n';
}

int main() {
    
    std::cout << '\n';
    
    std::jthread thr1 = std::jthread(func);
    std::jthread thr2 = std::jthread(func);
    thr1.request_stop();
    thr2.request_stop();

    std::cout << '\n';
    
}

// signalStopRequests.cpp

#include <iostream>
#include <thread>
#include <future>

using namespace std::literals;

void function1(std::stop_token stopToken, const std::string& str){
    std::this_thread::sleep_for(1s);
    if (stopToken.stop_requested()) std::cout << str << ": Stop requested\n";
}

void function2(std::promise<void> prom, 
               std::stop_token stopToken, const std::string& str) {
    std::this_thread::sleep_for(1s);
    std::stop_callback callBack(stopToken, [&str] { 
        std::cout << str << ": Stop requested\n"; 
    });
    prom.set_value();
}

int main() {

    std::cout << '\n';

    std::stop_source stopSource;                                                // (1)

    std::stop_token stopToken = std::stop_token(stopSource.get_token());        // (2)

    std::thread thr1 = std::thread(function1, stopToken, "std::thread");        // (3)
    
    std::jthread jthr = std::jthread(function1, stopToken, "std::jthread");     // (4)
    
    auto fut1 = std::async([stopToken] {                                        // (5)
        std::this_thread::sleep_for(1s);
        if (stopToken.stop_requested()) std::cout << "std::async: Stop requested\n";
    });

    std::promise<void> prom;                                                    // (6)
    auto fut2 = prom.get_future();
    std::thread thr2(function2, std::move(prom), stopToken, "std::promise");

    stopSource.request_stop();                                                  // (7)
    if (stopToken.stop_requested()) std::cout << "main: Stop requested\n";      // (8)

    thr1.join();
    thr2.join();

    std::cout << '\n';

}