{"id":9718,"date":"2024-07-15T08:43:25","date_gmt":"2024-07-15T08:43:25","guid":{"rendered":"https:\/\/www.modernescpp.com\/?p=9718"},"modified":"2024-07-15T08:43:26","modified_gmt":"2024-07-15T08:43:26","slug":"cooperative-interruption-of-a-thread-in-c20-callbacks","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/cooperative-interruption-of-a-thread-in-c20-callbacks\/","title":{"rendered":"Cooperative Interruption of a Thread in C++20: Callbacks"},"content":{"rendered":"\n

I introduced in my last post “Cooperative Interruption of a Thread in C++20<\/a>” callbacks. Today, I dive deeper.<\/p>\n\n\n\n

\"\"<\/figure>\n\n\n\n

First , here’s a short reminder.<\/p>\n\n\n\n

Reminder<\/h2>\n\n\n\n

In my last post “Cooperative Interruption of a Thread in C++20<\/a>“, I presented the following program.<\/p>\n\n\n\n

\/\/ invokeCallback.cpp<\/span>\n\n#include <chrono><\/span>\n#include <iostream><\/span>\n#include <thread><\/span>\n#include <vector><\/span>\n\nusing<\/span> namespace<\/span>::<\/span>std::<\/span>literals;\n\nauto<\/span> func =<\/span> [](std::<\/span>stop_token stoken) {                             \/\/ (1)<\/span>\n        int<\/span> counter{0<\/span>};\n        auto<\/span> thread_id =<\/span> std::<\/span>this_thread::<\/span>get_id();\n        std::<\/span>stop_callback callBack(stoken, [&<\/span>counter, thread_id] {  \/\/ (2)<\/span>\n            std::<\/span>cout <<<\/span> "Thread id: "<\/span> <<<\/span> thread_id \n                      <<<\/span> "; counter: "<\/span> <<<\/span> counter <<<\/span> '\\n'<\/span>;\n        });\n        while<\/span> (counter <<\/span> 10<\/span>) {\n            std::<\/span>this_thread::<\/span>sleep_for(0.2<\/span>s);\n            ++<\/span>counter;\n        }\n    };\n\nint<\/span> main<\/span>() {\n    \n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n    \n    std::<\/span>vector<<\/span>std::<\/span>jthread><\/span> vecThreads(10<\/span>);\n    for<\/span>(auto<\/span>&<\/span> thr:<\/span> vecThreads) thr =<\/span> std::<\/span>jthread(func);\n    \n    std::<\/span>this_thread::<\/span>sleep_for(1<\/span>s);                              \/\/ (3)<\/span>\n    \n    for<\/span>(auto<\/span>&<\/span> thr:<\/span> vecThreads) thr.request_stop();                \/\/ (4)<\/span>\n\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n    \n}\n<\/pre><\/div>\n\n\n\n
Each of the ten threads invokes the lambda function func<\/code> (1). The callback (2) displays the thread id<\/code> and the counter<\/code>. Due to the one-second sleeping of the main thread (3) and the sleeping of the child threads, the counter is 4 when the callbacks are invoked. The call thr.request_stop()<\/code> triggers the callback on each thread. <\/p>\n\n\n\n
\"\"<\/figure>\n\n\n\n
One question was not answered in my last post:<\/p>\n\n\n\n
Where does the callback run?<\/h3>\n\n\n\n
The std::stop_callback<\/code> constructor registers the callback function for the std::stop_token<\/code> given by the associated std::stop_source.<\/code> This callback function is either invoked in the thread invoking request_stop() <\/code>or the thread constructing the std::stop_callback.<\/code> If the request to stop happens prior to the registration of the std::stop_callback<\/code>, the callback is invoked in the thread constructing the std::stop_callback.<\/code> Otherwise, the callback is invoked in the thread invoking request_stop.<\/code>  If the call request_stop()<\/code>happens after the execution of the thread constructing the std::stop_callback<\/code>, the registered callback will never be called.  <\/p>\n\n\n\n
You can register more than one callback for one or more threads using the same std::stop_token.<\/code> The C++ standard does not guarantee the order in which they are executed.<\/p>\n\n\n\n
More than one callback<\/h3>\n\n\n\n
\/\/ invokeCallbacks.cpp<\/span>\n\n#include <chrono><\/span>\n#include <iostream><\/span>\n#include <thread><\/span>\n\nusing<\/span> namespace<\/span> std::<\/span>literals;\n\nvoid<\/span> func<\/span>(std::<\/span>stop_token stopToken) {\n    std::<\/span>this_thread::<\/span>sleep_for(100<\/span>ms);\n    for<\/span> (int<\/span> i =<\/span> 0<\/span>; i <=<\/span> 9<\/span>; ++<\/span>i) {\n       std::<\/span>stop_callback cb(stopToken, [i] { std::<\/span>cout <<<\/span> i; });\n    }\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n}\n\nint<\/span> main<\/span>() {\n    \n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n    \n    std::<\/span>jthread thr1 =<\/span> std::<\/span>jthread(func);\n    std::<\/span>jthread thr2 =<\/span> std::<\/span>jthread(func);\n    thr1.request_stop();\n    thr2.request_stop();\n\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n    \n}\n<\/pre><\/div>\n\n\n\n
\"\"<\/figure>\n\n\n\n
A General Mechanism to Send Signals<\/h2>\n\n\n\n
The pair std::stop_source <\/code>and std::stop_token<\/code> can be considered as a general mechanism to send a signal. By copying the std::stop_token<\/code>, you can send the signal to any entity executing something. In the following example, I use std::async,<\/code> std::promise, std::thread<\/code>, and std::jthread <\/code>in various combinations.<\/p>\n\n\n\n
\/\/ signalStopRequests.cpp<\/span>\n\n#include <iostream><\/span>\n#include <thread><\/span>\n#include <future><\/span>\n\nusing<\/span> namespace<\/span> std::<\/span>literals;\n\nvoid<\/span> function1<\/span>(std::<\/span>stop_token stopToken, const<\/span> std::<\/span>string&<\/span> str){\n    std::<\/span>this_thread::<\/span>sleep_for(1<\/span>s);\n    if<\/span> (stopToken.stop_requested()) std::<\/span>cout <<<\/span> str <<<\/span> ": Stop requested<\/span>\\n<\/span>"<\/span>;\n}\n\nvoid<\/span> function2<\/span>(std::<\/span>promise<<\/span>void<\/span>><\/span> prom, \n               std::<\/span>stop_token stopToken, const<\/span> std::<\/span>string&<\/span> str) {\n    std::<\/span>this_thread::<\/span>sleep_for(1<\/span>s);\n    std::<\/span>stop_callback callBack(stopToken, [&<\/span>str] { \n        std::<\/span>cout <<<\/span> str <<<\/span> ": Stop requested<\/span>\\n<\/span>"<\/span>; \n    });\n    prom.set_value();\n}\n\nint<\/span> main<\/span>() {\n\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n\n    std::<\/span>stop_source stopSource;                                                \/\/ (1)<\/span>\n\n    std::<\/span>stop_token stopToken =<\/span> std::<\/span>stop_token(stopSource.get_token());        \/\/ (2)<\/span>\n\n    std::<\/span>thread<\/span> thr1 =<\/span> std::<\/span>thread<\/span>(function1, stopToken, "std::thread"<\/span>);        \/\/ (3)<\/span>\n    \n    std::<\/span>jthread jthr =<\/span> std::<\/span>jthread(function1, stopToken, "std::jthread"<\/span>);     \/\/ (4)<\/span>\n    \n    auto<\/span> fut1 =<\/span> std::<\/span>async([stopToken] {                                        \/\/ (5)<\/span>\n        std::<\/span>this_thread::<\/span>sleep_for(1<\/span>s);\n        if<\/span> (stopToken.stop_requested()) std::<\/span>cout <<<\/span> "std::async: Stop requested<\/span>\\n<\/span>"<\/span>;\n    });\n\n    std::<\/span>promise<<\/span>void<\/span>><\/span> prom;                                                    \/\/ (6)<\/span>\n    auto<\/span> fut2 =<\/span> prom.get_future();\n    std::<\/span>thread<\/span> thr2(function2, std::<\/span>move(prom), stopToken, "std::promise"<\/span>);\n\n    stopSource.request_stop();                                                  \/\/ (7)<\/span>\n    if<\/span> (stopToken.stop_requested()) std::<\/span>cout <<<\/span> "main: Stop requested<\/span>\\n<\/span>"<\/span>;      \/\/ (8)<\/span>\n\n    thr1.join();\n    thr2.join();\n\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\n\n}\n<\/pre><\/div>\n\n\n\n
Thanks to the stopSource<\/code> (line 1), I can create the stopToken <\/code>(line 2) for each running entity, such as std::thread <\/code>(line 3), std::jthread <\/code>(line 4), std::async<\/code> (line 5), or std::promise<\/code> (line 6). A std::stop_token<\/code> is cheap to copy. Line 7 triggers stopSource.request_stop. <\/code>Also, the main thread (line 8) gets the signal. I use in this example std::jthread. std::jthread<\/code>, and std::condition_variable_any <\/code>has explicit member functions to deal with cooperative interruption more conveniently. Read more about it in the following post: “An Improved Thread with C++20<\/a>“.<\/p>\n\n\n\n
What’s next?<\/h2>\n\n\n\n
I will take a break in the next two weeks. Afterward, I will jump again in C++23 and add the first time in C++26.<\/p>\n\n\n\n
<\/p>\n\n\n\n
<\/p>\n\n\n\n
<\/p>\n","protected":false},"excerpt":{"rendered":"
I introduced in my last post “Cooperative Interruption of a Thread in C++20” callbacks. Today, I dive deeper. First , here’s a short reminder. Reminder In my last post “Cooperative Interruption of a Thread in C++20“, I presented the following program. \/\/ invokeCallback.cpp #include <chrono> #include <iostream> #include <thread> #include <vector> using namespace::std::literals; auto func […]<\/p>\n","protected":false},"author":21,"featured_media":9720,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[375],"tags":[],"class_list":["post-9718","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-c-20"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/9718","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/users\/21"}],"replies":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/comments?post=9718"}],"version-history":[{"count":25,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/9718\/revisions"}],"predecessor-version":[{"id":9746,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/9718\/revisions\/9746"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/9720"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=9718"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=9718"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=9718"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}