{"id":5533,"date":"2018-10-19T10:08:20","date_gmt":"2018-10-19T10:08:20","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/a-new-thread-with-c-20-std-jthread\/"},"modified":"2023-06-26T11:43:14","modified_gmt":"2023-06-26T11:43:14","slug":"a-new-thread-with-c-20-std-jthread","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/a-new-thread-with-c-20-std-jthread\/","title":{"rendered":"A new Thread with C++20: std::jthread"},"content":{"rendered":"

One of the participants in my CppCon 2018<\/a> workshop asked me: “Can a std::thread<\/span> be interrupted?”. No, that was my answer, but this is not correct anymore. With C++20, we might get a std::jthread.<\/span><\/p>\n

<\/p>\n

 <\/p>\n

Let me continue my story from the CppCon 2018. During a break from my concurrency workshop, I had a chat with Nicolai (Josuttis). He asked me what I think about the new proposal P0660: Cooperatively Interruptible Joining Thread. <\/a>At this point, I didn’t know the proposal. Nicolai is together with Herb Sutter and Anthony Williams one of the authors of the proposal. Today’s post is about the concurrent future. Here is the big picture to concurrency in current and upcoming C++.<\/p>\n

 \"timeline\"<\/p>\n

 <\/p>\n

From the title of the paper Cooperatively Interruptible Joining Thread <\/a>you may guess that the new thread has two new capabilities: interruptable and automatic joining. Let me first write about automatically joining. <\/a><\/p>\n<\/p>\n

Automatically joining<\/h2>\n

This is the non-intuitive behavior of std::thread.<\/span> If a std::thread<\/span> is still joinable, std::terminate<\/span> is called in its destructor. A thread thr<\/span> is joinable if either thr.join() <\/span>or thr.detach()<\/span> was called.<\/p>\n

\n
\/\/ threadJoinable.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <thread><\/span>\r\n\r\nint<\/span> main<\/span>(){\r\n    \r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n    std::<\/span>cout <<<\/span> std::<\/span>boolalpha;\r\n    \r\n    std::<\/span>thread<\/span> thr{[]{ std::<\/span>cout <<<\/span> \"Joinable std::thread\"<\/span> <<<\/span> std::<\/span>endl; }};\r\n    \r\n    std::<\/span>cout <<<\/span> \"thr.joinable(): \"<\/span> <<<\/span> thr.joinable() <<<\/span> std::<\/span>endl;\r\n    \r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n    \r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
When executed, the program terminates.<\/p>\n
\"threadJoinable\"<\/p>\n
 <\/p>\n
Both threads terminate. In the second run, the thread thr has enough time to display its message: “Joinable std::thread”.<\/p>\n
In the following example, I replace the header <thread><\/span> with “jthread.hpp” <\/span>and use std::jthread<\/span> from the upcoming C++ standard.<\/p>\n
\n
\/\/ jthreadJoinable.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include \"jthread.hpp\"<\/span>\r\n\r\nint<\/span> main<\/span>(){\r\n    \r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n    std::<\/span>cout <<<\/span> std::<\/span>boolalpha;\r\n    \r\n    std::<\/span>jthread thr{[]{ std::<\/span>cout <<<\/span> \"Joinable std::thread\"<\/span> <<<\/span> std::<\/span>endl; }};\r\n    \r\n    std::<\/span>cout <<<\/span> \"thr.joinable(): \"<\/span> <<<\/span> thr.joinable() <<<\/span> std::<\/span>endl;\r\n    \r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n    \r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
Now, the thread thr<\/span> automatically joins in its destructor, such as in this case if still joinable.<\/p>\n
\"jthreadJoinable\"<\/p>\n
Interrupt a std::jthread<\/span><\/h2>\n
To get a general idea, let me present a simple example.<\/p>\n
\n
\/\/ interruptJthread.cpp<\/span>\r\n\r\n#include \"jthread.hpp\"<\/span>\r\n#include <chrono><\/span>\r\n#include <iostream><\/span>\r\n\r\nusing<\/span> namespace<\/span>::<\/span>std::<\/span>literals;\r\n\r\nint<\/span> main<\/span>(){\r\n    \r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n    \r\n    std::<\/span>jthread nonInterruptable([]{                                   \/\/ (1)<\/span>\r\n        int<\/span> counter{0<\/span>};\r\n        while<\/span> (counter <<\/span> 10<\/span>){\r\n            std::<\/span>this_thread::<\/span>sleep_for(0.2<\/span>s);\r\n            std::<\/span>cerr <<<\/span> \"nonInterruptable: \"<\/span> <<<\/span> counter <<<\/span> std::<\/span>endl; \r\n            ++<\/span>counter;\r\n        }\r\n    });\r\n    \r\n    std::<\/span>jthread interruptable([](std::<\/span>interrupt_token itoken){         \/\/ (2)<\/span>\r\n        int<\/span> counter{0<\/span>};\r\n        while<\/span> (counter <<\/span> 10<\/span>){\r\n            std::<\/span>this_thread::<\/span>sleep_for(0.2<\/span>s);\r\n            if<\/span> (itoken.is_interrupted()) return<\/span>;                        \/\/ (3)<\/span>\r\n            std::<\/span>cerr <<<\/span> \"interruptable: \"<\/span> <<<\/span> counter <<<\/span> std::<\/span>endl; \r\n            ++<\/span>counter;\r\n        }\r\n    });\r\n    \r\n    std::<\/span>this_thread::<\/span>sleep_for(1<\/span>s);\r\n    \r\n    std::<\/span>cerr <<<\/span> std::<\/span>endl;\r\n    std::<\/span>cerr <<<\/span> \"Main thread interrupts both jthreads\"<\/span> <<<\/span> std::<\/span> endl;\r\n    nonInterruptable.interrupt();\r\n    interruptable.interrupt();                                          \/\/ (4)<\/span>\r\n    \r\n    std::<\/span>cout <<<\/span> std::<\/span>endl;\r\n    \r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
I started in the main program the two threads nonInterruptable<\/span> and interruptable<\/span> (lines 1 and 2). In contrast to the thread nonInterruptable,<\/span> the thread interruptable<\/span> gets a std::interrupt_token<\/span> and uses it in line 3 to check if it was interrupted: itoken.is_interrupted().<\/span> In case of an interrupt, the lambda function returns, and, therefore, the thread ends. The call interruptable.interrupt()<\/span> (line 4) triggers the end of the thread. This does not hold for the previous call nonInterruptable.interrupt(),<\/span> which has no effect.<\/p>\n
\"interruptJthread\"<\/p>\n
Here are more details to interrupt tokens, the joining threads, and condition variables.<\/p>\n
Interrupt Tokens<\/h3>\n
An interrupt token std::interrupt_token<\/span> models shared ownership and can be used to signal once if the token is valid. It provides three methods valid,<\/span> is_interrupted,<\/span> and interrupt.<\/span><\/p>\n
 \"interrupt<\/p>\n
If the interrupt token should be temporarily disabled, you can replace it with a default constructed token. A default constructed token is not valid. The following code snippet shows how to disable and enable a thread’s capability to accept signals.<\/p>\n
 <\/p>\n
\n
std::<\/span>jthread jthr([](std::<\/span>interrupt_token itoken){\r\n    ...\r\n    std::<\/span>interrupt_token interruptDisabled; \r\n    std::<\/span>swap(itoken, interruptDisabled);     \/\/ (1)       <\/span>\r\n    ...\r\n    std::<\/span>swap(itoken, interruptDisabled);     \/\/ (2)<\/span>\r\n    ...\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
 std::interrupt_token interruptDisabled<\/span> is not valid. This means that the thread can not accept an interrupt from line (1) to (2), but after line (2), it’s possible.<\/p>\n
Joining Threads<\/h3>\n
A std::jhread<\/span> is a std::thread<\/span> with the additional functionality to automatically signal an interrupt and join (). To support this functionality, it has a std::interrupt_token.<\/span><\/p>\n
\"jthread\"<\/h3>\n
New Wait Overloads for Condition Variables<\/h3>\n
The two wait variations <\/span>wait_for<\/span>, and wait_until<\/span> of the std::condition_variable<\/span> get new overloads. They take a std::interrupt_token.<\/span><\/p>\n
\n
template<\/span> <<\/span>class<\/span> Predicate<\/span>><\/span>\r\nbool<\/span> wait_until(unique_lock<<\/span>mutex>&<\/span> lock, \r\n                Predicate pred, \r\n                interrupt_token itoken);\r\n\r\ntemplate<\/span> <<\/span>class<\/span> Rep<\/span>, class<\/span> Period<\/span>, class<\/span> Predicate<\/span>><\/span>\r\nbool<\/span> wait_for(unique_lock<<\/span>mutex>&<\/span> lock, \r\n              const<\/span> chrono::<\/span>duration<<\/span>Rep, Period>&<\/span> rel_time, \r\n              Predicate pred, \r\n              interrupt_token itoken);\r\n\r\ntemplate<\/span> <<\/span>class<\/span> Clock<\/span>, class<\/span> Duration<\/span>, class<\/span> Predicate<\/span>><\/span>\r\nbool<\/span> wait_until(unique_lock<<\/span>mutex>&<\/span> lock, \r\n                const<\/span> chrono::<\/span>time_point<<\/span>Clock, Duration>&<\/span> abs_time, \r\n                Predicate pred, \r\n                interrupt_token itoken);\r\n<\/pre>\n<\/div>\n
 <\/p>\n
These new overloads require a predicate. The versions ensure to get notified if an interrupt is signalled for the passed std::interrupt_token itoken<\/span>. After the wait calls, you can check if an interrupt occurred.<\/p>\n
\n
cv.wait_until(lock, predicate, itoken);\r\nif<\/span> (itoken.is_interrupted()){\r\n    \/\/ interrupt occurred<\/span>\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
What’s next?<\/h2>\n
As I promised in my last post, my next post<\/a> is about the remaining rules for defining concepts.<\/p>\n
 <\/p>\n
 <\/p><\/p>\n","protected":false},"excerpt":{"rendered":"
One of the participants in my CppCon 2018 workshop asked me: “Can a std::thread be interrupted?”. No, that was my answer, but this is not correct anymore. With C++20, we might get a std::jthread.<\/p>\n","protected":false},"author":21,"featured_media":4724,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[367],"tags":[448],"class_list":["post-5533","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-multithreading-c-17-and-c-20","tag-jthread"],"_links":{"self":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5533","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=5533"}],"version-history":[{"count":1,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5533\/revisions"}],"predecessor-version":[{"id":6809,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/5533\/revisions\/6809"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/4724"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=5533"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=5533"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=5533"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}