![\"TimelineCpp20Interruption\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2021\/02\/TimelineCpp20Interruption.png\")
<\/p>\nA typical question in my C++ seminars is: Can a\u00a0 thread be killed? Before C++20, my answer is no. With C++20, you can ask a thread politely for its interruption.<\/p>\n
<\/p>\n
<\/p>\n
First of all. Why is it not a good idea to kill a thread? The answer is relatively easy. You don’t know which state the thread is in when you kill it. Here are two possible malicious outcomes.<\/p>\n
Okay, killing a thread is not a good idea. You may ask a thread friendly if it is willing to stop. This is precisely what cooperative interruption in C++20 means. You ask the thread, and the thread can accept or ignore your wish for the interruption.<\/p>\n
The additional functionality of the cooperative interruption thread in C++20 is based on the A You can construct a <\/p>\n The default constructor (1) constructs a The call est has been made or can be made for its associated stop source The following table presents the member functions of a A default-constructed token that has no associated stop state. If the <\/p>\n When you study the code snippet carefully, you may wonder if the used My next example shows the use of callbacks using a <\/p>\n Each of the ten threads invokes the lambda function As mentioned,\u00a0 You may have noticed it. This post is a repetition of a post I have written 3 1\/2 years ago. The reason is simple. I need this post as a prerequisite for my next post, and I don’t want to write a post two times.<\/p>\n","protected":false},"excerpt":{"rendered":" A typical question in my C++ seminars is: Can a\u00a0 thread be killed? Before C++20, my answer is no. With C++20, you can ask a thread politely for its interruption.<\/p>\n","protected":false},"author":21,"featured_media":6079,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[375],"tags":[448],"class_list":["post-9692","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-c-20","tag-jthread"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/9692","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=9692"}],"version-history":[{"count":2,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/9692\/revisions"}],"predecessor-version":[{"id":9716,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/9692\/revisions\/9716"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/6079"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=9692"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=9692"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=9692"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}std::stop_token<\/code>, the std::stop_callback<\/code>, and the std::stop_source<\/code>\u00a0data types.<\/p>\nstd::stop_token<\/code>, std::stop_callback<\/code>, and std::stop_source<\/code><\/h3>\nstd::stop_token<\/code>, a std::stop_callback<\/code>, or a std::stop_source<\/code>\u00a0allows a thread to asynchronously request an execution to stop or ask if an execution got a stop signal. The std::stop_token<\/code> can be passed to an operation and afterward be used to poll the token for a stop request actively or to register a callback via std::stop_callback<\/code>. The stop request is sent by a std::stop_source<\/code>. This signal affects all associated std::stop_token<\/code>. The three classes std::stop_source<\/code>, std::stop_token<\/code>, and std::stop_callback<\/code>\u00a0share the ownership of an associated stop state. The calls request_stop()<\/code>, stop_requested()<\/code>, and stop_possible()<\/code> are atomic.<\/p>\nstd::stop_source<\/code> in two ways:<\/p>\n\nstop_source(); \/\/ (1)<\/span>\nexplicit<\/span> stop_source(std::<\/span>nostopstate_t<\/span>) noexcept; \/\/ (2)<\/span>\n<\/pre>\n<\/div>\nstd::stop_source<\/code> with a new stop state. The constructor taking std::nostopstate_t<\/code> (2) constructs an empty std::stop_source<\/code> without associated stop state.
\nThe component\u00a0std::stop_source src<\/code>\u00a0provides the following member functions for handling stop requests.<\/p>\n![\"stopSource\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2021\/02\/stopSource.png\")
<\/p>\nsrc.stop_possible()<\/code> means that src<\/code> has an associated stop state. src.stop_requested()<\/code> returns true<\/code> when src<\/code> has an associated stop state and was not asked to stop earlier. src.request_stop()<\/code> is successful and returns true<\/code> if src<\/code> has an associated stop state, which was not requested to stop before.<\/p>\nsrc.get_token()<\/code> returns the stop token stoken<\/code>. Thanks to stoken<\/code> you can check if a stop requ<\/p>\nsrc<\/code>. The stop token stoken<\/code> observes the stop source src<\/code>.<\/p>\nstd::stop_token stoken<\/code>.<\/p>\n![\"stopToken\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2021\/02\/stopToken.png\")
<\/p>\n stoken.stop_possible<\/code> also returns true<\/code> if stoken<\/code> has an associated stop state.\u00a0stoken.stop_requested()<\/code> returns true<\/code> when the stop token has an associated stop state and has already received a stop request.<\/p>\nstd::stop_token<\/code> should be temporarily disabled, you can replace it with a default constructed token. A default constructed token has no associated stop-state. The following code snippet shows how to disable and enable a thread’s capability to accept stop requests.<\/p>\n\nstd::<\/span>jthread jthr([](std::<\/span>stop_token stoken) {\n ...\n std::<\/span>stop_token interruptDisabled;\n std::<\/span>swap(stoken, interruptDisabled); \/\/ (1)<\/span>\n ... \/\/ (2)<\/span>\n std::<\/span>swap(stoken, interruptDisabled);\n ...\n}\n<\/pre>\n<\/div>\nstd::stop_token interruptDisabled<\/code> has no associated stop state. This means the thread jthr<\/code> can, in all lines except lines (1) and (2), accept stop requests.<\/p>\nstd::jthread. std::jthread<\/code> in C++20 is an extended std::thread<\/code> in C++11. The j<\/strong> in jthread<\/code> stands for joinable because it joins automatically in its destructor. Its first name was ithread<\/code>. You may guess why: i<\/strong> stands for interruptible. I will present std::jthread<\/code> in my next post.<\/p>\nstd::jthread.<\/code><\/p>\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>\n<\/div>\n 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![\"invokeCallback\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2021\/02\/invokeCallback.png\")
<\/p>\nWhat’s next?<\/h2>\n
std::thread<\/code> has one significant weakness. When you forget to join it, its destructor calls std::terminate<\/code>, and your program crashes. std::jthread<\/code> (C++20) overcomes this counter-intuitive weakness and is also interruptible.<\/p>\nRepetition<\/h2>\n