how to safely register std::stop_callback with std::jthread - c++

Question

I'm a bit confused about how to safely register callbacks for jthread. You need the token so that means that you would need to do the registration after creating the jthread which means that the callback would be destroyed before the jthread. In the example below cb5 and cb6 obviously get destroyed before the dtor of the jthread starts so they automatically deregister themselves and never execute. Conversely, cb1 and cb2 are explicitly destroyed after the destruction of jthread so they are guaranteed to execute as a side effect to the dtor requesting a stop. Now the confusing part is that I can not find any guarantees that cb3 and cb4 are guaranteed to execute. There is nothing I could find that says that requesting stop would atomically change set the stop flag and execute all the callbacks for example. On the other hand, I looked at the Implementation:223 of request_stop and it seems that it does the following
takes a lock
set the stop flag and fetch the last registered stop callback
release the lock
run the callback
release the binary semaphore (which the destructor of that callback waits on)
tries to reacquire the lock to execute the next callback
Now finally to the question, according to the above, the execution of cb3 and cb4 is racing with their destructors (at least cb3, because cb4 will be chosen for execution under the same lock that will be used to set the stop flag, but again I could not find that guarantee for cb4 mentioned somewhere). So how can one use a stop_callback properly with a jthread without calling request_stop explicitly? you can't register the callbacks after because they will be destroyed before like cb5 and cb6 and you can't register them withing the thread because they are not guaranteed to execute like cb3 and cb4 and I do not think that it was intended to give them a longer lifetime in the convoluted way of cb1 and cb2
#include <chrono>
#include <iostream>
#include <stop_token>
#include <thread>
int main(int argc, const char * const * const argv)
{
using namespace std::chrono_literals;
const auto _cb1 = []() -> void {
std::cout << "cb1\n";
std::this_thread::yield();
std::this_thread::sleep_for(10s);
};
const auto _cb2 = []() -> void {
std::cout << "cb2\n";
std::this_thread::yield();
std::this_thread::sleep_for(10s);
};
using CB1 =
decltype(std::stop_callback(std::declval<std::stop_token>(), _cb1));
using CB2 =
decltype(std::stop_callback(std::declval<std::stop_token>(), _cb2));
std::byte storage1[sizeof(CB1)];
std::byte storage2[sizeof(CB2)];
const CB1 * cb1 = nullptr;
const CB2 * cb2 = nullptr;
{
std::jthread worker([](const std::stop_token & stop_token) {
std::stop_callback cb3(stop_token, [] {
std::cout << "cb3\n";
std::this_thread::yield();
std::this_thread::sleep_for(10s);
});
std::stop_callback cb4(stop_token, [] {
std::cout << "cb4\n";
std::this_thread::yield();
std::this_thread::sleep_for(10s);
});
while (!stop_token.stop_requested())
{
}
});
cb1 = new (&storage1) std::stop_callback(worker.get_stop_token(), _cb1);
cb2 = new (&storage2) std::stop_callback(worker.get_stop_token(), _cb2);
std::stop_callback cb5(worker.get_stop_token(), [] {
std::cout << "cb5\n";
std::this_thread::yield();
std::this_thread::sleep_for(10s);
});
std::stop_callback cb6(worker.get_stop_token(), [] {
std::cout << "cb6\n";
std::this_thread::yield();
std::this_thread::sleep_for(10s);
});
std::this_thread::sleep_for(2s);
}
cb1->~CB1();
cb2->~CB2();
return 0;
}

Answer 1

The standard directly states that:
A call to request_­stop that returns true synchronizes with a call to stop_requested on an associated stop_­token or stop_­source object that returns true.
This means that a call to stop_requested that returns true "happens after" any request_stop that returns true. So your while loop cannot exit until a call to request_stop actually returns true to some thread. More importantly, it cannot exit until such a call returns.
request_stop is explicitly stated to:
If the request was made, the callbacks registered by associated stop_callback objects are synchronously called.
Being called "synchronously" means exactly that: this function will either call them on the thread requesting the stop or it will synchronize with whatever thread(s) they do get called on. The main point being that until those callbacks are finished, this function does not return.
And until this function returns, stop_requested will not return true, as previously stated.
So there is no data race. The callbacks will not be destroyed before the thread exits.