![\"threadForgetJoin\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2016\/04\/threadForgetJoin.png\")
<\/p>\n<\/code><\/code><\/article>\n<\/article>\n<\/article>\n<\/article>\n\n\/\/ scoped_thread.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <thread><\/span>\r\n#include <utility><\/span>\r\n\r\n\r\nclass<\/span> scoped_thread<\/span>{\r\n std::<\/span>thread<\/span> t;\r\npublic:<\/span>\r\n explicit<\/span> scoped_thread<\/span>(std::<\/span>thread<\/span> t_):<\/span> t(std::<\/span>move(t_)){\r\n if<\/span> ( !<\/span>t.joinable()) throw<\/span> std::<\/span>logic_error(\"No thread\"<\/span>);\r\n }\r\n ~<\/span>scoped_thread(){\r\n t.join();\r\n }\r\n scoped_thread(scoped_thread&<\/span>)=<\/span> delete<\/span>;\r\n scoped_thread&<\/span> operator<\/span>=<\/span>(scoped_thread const<\/span> &<\/span>)=<\/span> delete<\/span>;\r\n};\r\n\r\nint<\/span> main<\/span>(){\r\n\r\n scoped_thread t(std::<\/span>thread<\/span>([]{std::<\/span>cout <<<\/span> std::<\/span>this_thread::<\/span>get_id() <<<\/span> std::<\/span>endl;}));\r\n\r\n}\r\n<\/pre>\n<\/div>\n <\/p>\n
The scoped_thread<\/span> checks in its constructor if the given thread is joinable and joins in its destructor the given thread.<\/p>\nCP.26: Don\u2019t detach()<\/code> a thread<\/a><\/h3>\nThis rule sounds strange. The C++11 standard supports detaching a thread, but we should not do it! The reason is that detaching a thread can be quite challenging. As rule, C.25 said: CP.24: Think of an thread<\/code> as a global container<\/a>. Of course, this means you are magnificent if you use only variables with global scope in the detached threads. NO!<\/p>\nEven objects with static duration can be critical. For example, look at this small program with undefined behavior.<\/p>\n
\n#include <iostream>
#include <string>
#include <thread>
void<\/span> func<\/span>(){\r\n std::<\/span>string s{\"C++11\"<\/span>};\r\n std::<\/span>thread<\/span> t([&s<\/span>]{ std::<\/span>cout <<<\/span> s <<<\/span> std::<\/span>endl;});\r\n t.detach();\r\n}
int main(){
func();
}\r\n<\/pre>\n<\/div>\n <\/p>\n
This is easy. The lambda function takes s by reference. This is undefined behavior because the child thread t uses the variable s, which goes out of scope. STOP! This is the apparent problem but the hidden issue is std::cout. std::cout<\/span> <\/span>has a static duration. This means the lifetime of std::cout<\/span> ends with the end of the program, and we have, additionally, a race condition<\/a>: thread t may use std::cout<\/span> at this time. <\/p>\nWhat’s next?<\/h2>\n
![\"gleise\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2018\/05\/gleise.jpg\")
<\/p>\n