thread destructors in C++0x vs boost

Question

These days I am reading the pdf Designing MT programs . It explains that the user MUST explicitly call detach() on an object of class std::thread i

Answer 1

This is indeed true, and this choice is explained in N3225 on a note regarding std::thread destructor :

If joinable() then terminate(), otherwise no effects. [ Note: Either implicitly detaching or joining a joinable() thread in its destructor could result in difficult to debug correctness (for detach) or performance (for join) bugs encountered only when an exception is raised. Thus the programmer must ensure that the destructor is never executed while the thread is still joinable. —end note ]

Apparently the committee went for the lesser of two evils.

---

EDIT I just found this interesting paper which explains why the initial wording :

If joinable() then detach(), otherwise no effects.

was changed for the previously quoted one.

Answer 2

Here's one way to implement RAII threads.

#include <memory>
#include <thread>

void run() { /* thread runs here */ }

struct ThreadGuard
{
    operator()(std::thread* thread) const
    {
        if (thread->joinable())
            thread->join(); // this is safe, but it blocks when scoped_thread goes out of scope
        //thread->detach(); // this is unsafe, check twice you know what you are doing
        delete thread;
    }
}

auto scoped_thread = std::unique_ptr<std::thread, ThreadGuard>(new std::thread(&run), ThreadGuard());

If you want to use this to detach a thread, read this first.