{"id":6087,"date":"2021-02-12T10:28:52","date_gmt":"2021-02-12T10:28:52","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/an-improved-thread-with-c-20\/"},"modified":"2021-02-12T10:28:52","modified_gmt":"2021-02-12T10:28:52","slug":"an-improved-thread-with-c-20","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/an-improved-thread-with-c-20\/","title":{"rendered":"An Improved Thread with C++20"},"content":{"rendered":"

std::jthread<\/code> stands for joining thread. In addition to std::thread<\/code> (C++11), std::jthread<\/code> automatically joins in its destructor and can cooperatively be interrupted. Read this post to know why std::jthread<\/code> should be your first choice.<\/p>\n

<\/p>\n

 \"TimelineCpp20\"<\/p>\n

The following table gives you a concise overview of the functionality of std::jthread<\/code>.<\/p>\n

\"jthread\"<\/p>\n

 <\/p>\n

For additional details, please refer to cppreference.com<\/a>. When you want to read more posts about std::thread<\/code>, here are they: my post about std::thread.<\/a><\/p>\n

First, why do we need an improved thread in C++20? Here is the first reason.<\/p>\n<\/p>\n

Automatically Joining<\/h2>\n

This is the non-intuitive<\/strong> behavior of std::thread<\/code>. If a std::thread<\/code> is still joinable, std::terminate<\/a> is called in its destructor. A thread thr<\/code> is joinable if neither thr.join()<\/code> nor thr.detach()<\/code> was called. Let me show what that means.<\/p>\n

<\/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> '\\n'<\/span>;\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> '\\n'<\/span>; }};\r\n    \r\n    std::<\/span>cout <<<\/span> \"thr.joinable(): \"<\/span> <<<\/span> thr.joinable() <<<\/span> '\\n'<\/span>;\r\n    \r\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n    \r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
When executed, the program terminates when the local object thr<\/code> goes out of scope.<\/p>\n
\"threadJoinable\"<\/p>\n
Both executions of std::thread<\/code> terminate. In the second run, the thread thr<\/code> has enough time to display its message: Joinable std::thread<\/code>.<\/p>\n
In the next example, I use std::jthread<\/code> from the C++20 standard.<\/p>\n
<\/p>\n
\n
\/\/ jthreadJoinable.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> '\\n'<\/span>;\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> '\\n'<\/span>; }};\r\n    \r\n    std::<\/span>cout <<<\/span> \"thr.joinable(): \"<\/span> <<<\/span> thr.joinable() <<<\/span> '\\n'<\/span>;\r\n    \r\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n    \r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
Now, the thread thr<\/code> automatically joins in its destructor if it’s still joinable such as in this case.<\/p>\n
\"jthreadJoinable\"<\/p>\n
But this is not all that std::jthread<\/code>  provides additionally to std::thread<\/code>. A std::jthread<\/code> can be cooperatively interrupted. I already presented the general ideas of cooperative interruption in my last post: Cooperative Interruption of a Thread in C++20<\/a>.<\/p>\n
Cooperative Interruption of a std::jthread<\/code><\/h2>\n
To get a general idea, let me present a simple example.<\/p>\n
<\/p>\n
\n
\/\/ interruptJthread.cpp<\/span>\r\n\r\n#include <chrono><\/span>\r\n#include <iostream><\/span>\r\n#include <thread><\/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> '\\n'<\/span>;\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> '\\n'<\/span>; \r\n            ++<\/span>counter;\r\n        }\r\n    });\r\n    \r\n    std::<\/span>jthread interruptable([](std::<\/span>stop_token stoken){     \/\/ (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> (stoken.stop_requested()) return<\/span>;               \/\/ (3)<\/span>\r\n            std::<\/span>cerr <<<\/span> \"interruptable: \"<\/span> <<<\/span> counter <<<\/span> '\\n'<\/span>; \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> '\\n'<\/span>;\r\n    std::<\/span>cerr <<<\/span> \"Main thread interrupts both jthreads\"<\/span> <<<\/span> '\\n'<\/span>;\r\n    nonInterruptable.request_stop();\r\n    interruptable.request_stop();                              \/\/ (4)<\/span>\r\n    \r\n    std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n    \r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
In the main program, I start the two threads nonInterruptable<\/code> and interruptable (lines 1)and 2). Unlike in the thread nonInterruptable<\/code> , the thread interruptable<\/code> gets a std::stop_token<\/code> and uses it in line (3) to check if it was interrupted: stoken.stop_requested()<\/code>. In case of a stop request, the lambda function returns, and the thread ends. The call interruptable.request_stop()<\/code> (line 4) triggers the stop request. This does not hold for the previous call nonInterruptable.request_stop()<\/code> . The call has no effect.<\/p>\n
\"interruptJthread\"<\/p>\n
To complete my post, with C++20, you can also cooperatively interrupt a condition variable.<\/p>\n
New wait Overloads for std::condition_variable_any<\/code><\/h2>\n
Before I write about std::condition_variable_any<\/code>, here are my post about condition variables<\/a>. <\/p>\n
The three wait variations wait<\/code>, wait_for<\/code>, and wait_until<\/code> of the std::condition_variable_any get new overloads. These overloads take a std::stop_token<\/code>.<\/p>\n
<\/p>\n
\n
template<\/span> <<\/span>class<\/span> Predicate<\/span>><\/span>\r\nbool<\/span> wait(Lock&<\/span> lock,  \r\n          stop_token stoken,\r\n          Predicate pred);\r\n\r\ntemplate<\/span> <<\/span>class<\/span> Rep<\/span>, class<\/span> Period<\/span>, class<\/span> Predicate<\/span>><\/span>\r\nbool<\/span> wait_for(Lock&<\/span> lock, \r\n              stop_token stoken, \r\n              const<\/span> chrono::<\/span>duration<<\/span>Rep, Period>&<\/span> rel_time, \r\n              Predicate pred);\r\n                \r\ntemplate<\/span> <<\/span>class<\/span> Clock<\/span>, class<\/span> Duration<\/span>, class<\/span> Predicate<\/span>><\/span>\r\nbool<\/span> wait_until(Lock&<\/span> lock, \r\n                stop_token stoken,\r\n                const<\/span> chrono::<\/span>time_point<<\/span>Clock, Duration>&<\/span> abs_time, \r\n                Predicate pred);\r\n<\/pre>\n<\/div>\n
 <\/p>\n
These new overloads need a predicate. The presented versions ensure getting notified if a stop request for the passed std::stop_token stoken<\/code> is signaled. They return a boolean that indicates whether the predicate evaluates to true<\/code>. This returned boolean is independent of whether a stop was requested or whether the timeout was triggered.<\/p>\n
After the wait calls, you can check if a stop request occurred.<\/p>\n
<\/p>\n
\n
cv.wait(lock, stoken, predicate);\r\nif<\/span> (stoken.stop_requested()){\r\n    \/\/ interrupt occurred<\/span>\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
The following example shows the usage of a condition variable with a stop request.<\/p>\n
<\/p>\n
\n
\/\/ conditionVariableAny.cpp<\/span>\r\n\r\n#include <condition_variable><\/span>\r\n#include <thread><\/span>\r\n#include <iostream><\/span>\r\n#include <chrono><\/span>\r\n#include <mutex><\/span>\r\n#include <thread><\/span>\r\n\r\nusing<\/span> namespace<\/span> std::<\/span>literals;\r\n\r\nstd::<\/span>mutex mutex_;\r\nstd::<\/span>condition_variable_any condVar;\r\n\r\nbool<\/span> dataReady;\r\n\r\nvoid<\/span> receiver<\/span>(std::<\/span>stop_token stopToken) {                 \/\/ (1)<\/span>\r\n\r\n    std::<\/span>cout <<<\/span> \"Waiting\"<\/span> <<<\/span> '\\n'<\/span>;\r\n\r\n    std::<\/span>unique_lock<<\/span>std::<\/span>mutex><\/span> lck(mutex_);\r\n    bool<\/span> ret =<\/span> condVar.wait(lck, stopToken, []{return<\/span> dataReady;});\r\n    if<\/span> (ret){\r\n        std::<\/span>cout <<<\/span> \"Notification received: \"<\/span> <<<\/span> '\\n'<\/span>;\r\n    }\r\n    else<\/span>{\r\n         std::<\/span>cout <<<\/span> \"Stop request received\"<\/span> <<<\/span> '\\n'<\/span>;\r\n    }\r\n}\r\n\r\nvoid<\/span> sender<\/span>() {                                            \/\/ (2)<\/span>\r\n\r\n    std::<\/span>this_thread::<\/span>sleep_for(5<\/span>ms);\r\n    {\r\n        std::<\/span>lock_guard<<\/span>std::<\/span>mutex><\/span> lck(mutex_);\r\n        dataReady =<\/span> true<\/span>;\r\n        std::<\/span>cout <<<\/span> \"Send notification\"<\/span>  <<<\/span> '\\n'<\/span>;\r\n    }\r\n    condVar.notify_one();                                  \/\/ (3)<\/span>\r\n\r\n}\r\n\r\nint<\/span> main<\/span>(){\r\n\r\n  std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n\r\n  std::<\/span>jthread t1(receiver);\r\n  std::<\/span>jthread t2(sender);\r\n  \r\n  t1.request_stop();                                       \/\/ (4)<\/span>\r\n\r\n  t1.join();\r\n  t2.join();\r\n\r\n  std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n  \r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
The receiver thread (line 1) is waiting for the notification of the sender thread (line 2). Before the sender thread sends its notification (line 3), the main thread triggers a stop request in line (4). The program’s output shows that the stop request happened before the notification.<\/p>\n
\"conditionVariableAny\"<\/h2>\n
What’s next?<\/h2>\n
What happens when your write without synchronization to std::cout<\/code>? You get a mess. Thanks to C++20, we have synchronized output streams.<\/p>\n<\/p>\n
 <\/p>\n
 <\/code><\/div>\n","protected":false},"excerpt":{"rendered":"
std::jthread stands for joining thread. In addition to std::thread (C++11), std::jthread automatically joins in its destructor and can cooperatively be interrupted. Read this post to know why std::jthread should be your first choice.<\/p>\n","protected":false},"author":21,"featured_media":5199,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[375],"tags":[],"class_list":["post-6087","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\/6087","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=6087"}],"version-history":[{"count":0,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/posts\/6087\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media\/5199"}],"wp:attachment":[{"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/media?parent=6087"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/categories?post=6087"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.modernescpp.com\/index.php\/wp-json\/wp\/v2\/tags?post=6087"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}