In the book 

> 
> "C++ Concurrency In Action" by Anthony Williams
> 
> 
> 

you can find the following two snippet of code (I have introduced some slight modifications):

Snippet 1:

```
class thread_guard
{
    std::thread& t;
    public:
    explicit thread_guard(std::thread& t_): t(t_){}
    ~thread_guard()
    {
        if(t.joinable())
    {
        t.join();
    }
    }
    thread_guard(thread_guard const&)=delete;
    thread_guard& operator=(thread_guard const&)=delete;
};

void my_func()
{
    for(int j = 0; j < 1000; ++j)
    {
        cout << "\n " << j;
    }
}

void f()
{
    std::thread t1(my_func);
    thread_guard g(t1);
    do_something_in_current_thread();
}

int main()
{
    f();
    return 0;
}

```

Going on you can find

Snippet 2:

```
class scoped_thread
{
    std::thread t;
    public:
    explicit scoped_thread(std::thread t_):    t(std::move(t_))
    {
        if(!t.joinable())
        throw std::logic_error(“No thread”);
    }
    ~scoped_thread()
    {
        t.join();
    }
    scoped_thread(scoped_thread const&)=delete;
    scoped_thread& operator=(scoped_thread const&)=delete;
};

void my_func()
{
    for(int j = 0; j < 1000; ++j)
    {
        cout << "\n " << j;
    }
}

void f()
{
   scoped_thread st1(thread(my_func));

   thread t2(my_func);
   scoped_thread st2(move(t2));

   do_something_in_current_thread();
}

int main()
{
    f();
    return 0;
}

```

I'm not sure that I can really appreciate the real difference between these 2 snippets.

The only difference that I can see is that in Snippet 1 the instance of `thread_guard` does not take ownership of the thread `t1` (unlike a `scoped_thread` object) and so it could be possible call `t1.join()` but this is not a problem when `~thread_guard()` is executed.

So: where is (if exists) the advantage of Snippet 2?