\/\/ threadWithoutJoin.cpp<\/span>
#include <iostream><\/span>\r\n#include <thread><\/span>\r\n\r\nint<\/span> main(){\r\n\r\n std::thread<\/span> t([]{std::cout << std::this_thread::get_id() << std::endl;});\r\n\r\n}\r\n<\/pre>\n<\/div>\n <\/p>\n
But the program run results in an unexpected result.<\/p>\n
![\"threadForgetJoin\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2016\/04\/threadForgetJoin.png\")
<\/p>\n
What’s the reason?<\/p>\n<\/p>\n
join and detach<\/h2>\n
The lifetime of the created thread t<\/span> ends with its callable unit. The creator has two choices. First: it waits until its child is done (t.join()<\/span>). Second: it detaches itself from its child: t.detach()<\/span>. A thread t<\/span> with the callable unit (you can create threads without a callable unit) is joinable, in case there were no t.join() or t.detach calls to the thread. A joinable thread destructor throws std::terminate<\/span> exception. Thus, the program terminates. That is the reason, the actual run terminated unexpectedly.<\/p>\nThe solution to this problem is simple. By calling t.join(),<\/span> the program behaves as it should.<\/p>\n<\/p>\n
\n\/\/ threadWithJoin.cpp<\/span>
#include <iostream><\/span>\r\n#include <thread><\/span>\r\n\r\nint<\/span> main(){\r\n\r\n std::thread<\/span> t([]{std::cout << std::this_thread::get_id() << std::endl;});\r\n\r\n t.join(); \r\n\r\n}\r\n<\/pre>\n<\/div>\n <\/p>\n
![\"threadJoin\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2016\/04\/threadJoin.png\")
<\/p>\n
A short side note: The challenges of detaching<\/span>
<\/span><\/h3>\nOf course, you can use t.detach() instead of t.join() in the program above. The thread t is not joinable anymore, and its destructor didn’t call std::terminate<\/span>. Seems terrible because now the program behavior is undefined because the lifetime of the object std::cout<\/span> is not ensured. The execution of the program goes a little bit odd.<\/p>\n <\/span><\/p>\n![\"threadDetach\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2016\/04\/threadDetach.png\")
<\/span><\/p>\nI will elaborate more on this issue in the following article.<\/span>
<\/span> <\/span> <\/span> <\/span> <\/span><\/p>\nMoving threads <\/h2>\n
Until now, it was quite easy. But that has not to be forever.<\/p>\n
It is impossible to copy a thread (copy semantic); you can only move (move semantic<\/a>) it. If a thread is moved, it’s a lot more challenging to deal with its lifetime in the right way.<\/p>\n<\/p>\n
\n\/\/ threadMoved.cpp<\/span>
#include <iostream> <\/span>\r\n#include <thread> <\/span>\r\n#include <utility><\/span>\r\n\r\nint<\/span> main(){ \r\n\r\n std::thread<\/span> t([]{std::cout << std::this_thread::get_id();}); \r\n std::thread<\/span> t2([]{std::cout << std::this_thread::get_id();}); \r\n \r\n t= std::move(t2); \r\n t.join(); \r\n t2.join(); \r\n\r\n}\r\n<\/pre>\n<\/div>\n <\/p>\n
Both threads – t1 and t2 should do a simple job: print their IDs. In addition, thread t2 will be moved to t: t= std::move(t2).<\/span> In the end, the main <\/span>thread takes care of its children and joins them. But wait. That’s far away from my expectations:<\/p>\n ![\"threadMove\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2016\/04\/threadMove.png\")
<\/p>\n
What is going wrong? We have two issues:<\/p>\n
\n- By moving (taking ownership of) the thread t2, t gets a new callable unit, and its destructor will be called. So it’s destructor calls std::terminate<\/span>, because it is still joinable.<\/li>\n
- Thread t2 has no associated callable unit. The invocation of join on a thread without a callable unit leads to the exception std::system_error<\/span>.<\/li>\n<\/ol>\n
I fixed both errors.<\/p>\n
<\/p>\n
\n\/\/ threadMovedFixed.cpp<\/span>
#include <iostream> <\/span>\r\n#include <thread> <\/span>\r\n#include <utility><\/span>\r\n\r\nint<\/span> main(){ \r\n\r\n std::thread<\/span> t([]{std::cout << std::this_thread::get_id() << std::endl;}); \r\n std::thread<\/span> t2([]{std::cout << std::this_thread::get_id() << std::endl;}); \r\n \r\n t.join();\r\n t= std::move(t2); \r\n t.join(); \r\n \r\n std::cout << \"\\n\"<\/span>;\r\n std::cout << std::boolalpha << \"t2.joinable(): \"<\/span> << t2.joinable() << std::endl;\r\n\r\n}\r\n<\/pre>\n<\/div>\n <\/p>\n
As a result, thread t2 is not joinable anymore.<\/span><\/em><\/p>\n![\"threadMoveRight\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2016\/04\/threadMoveRight.png\")
<\/p>\n
scoped_thread<\/h2>\n
If it’s too bothersome for you to take care of the lifetime of your threads by hand, you can encapsulate a std::thread<\/span> in your wrapper class. This class should automatically call join in his destructor. Of course, you can go the other way around and call detach. But you know, there are a few issues with detachment.<\/p>\n