c++ - thread_guard 与 scoped_thread

Question

在书中

"C++ Concurrency In Action" by Anthony Williams

您可以找到以下两段代码(我已经引入了一些小的修改):

片段 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;
}

继续往前走可以找到

片段 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;
}

我不确定我是否能真正理解这两个片段之间的真正区别。

我能看到的唯一区别是，在片段 1 中，thread_guard 的实例没有取得线程 t1 的所有权(不同于 scoped_thread object)，因此可以调用 t1.join() 但在执行 ~thread_guard() 时这不是问题。

那么:Snippet 2 的优势在哪里(如果存在的话)？

Answer 1

这两种类型都旨在阻止销毁(例如范围退出)，直到线程完成。区别在于 thread 对象的所有权。

thread_guard 不拥有 thread 本身；可能有多个 thread_guard 在等待同一个 thread。这也意味着只要任何 thread_guard 引用它，thread 对象就必须存活。如果在销毁 thread_guard 对象时引用的线程已经加入，它不会阻塞或产生错误(与仅在线程上调用 join 相反)不可加入)。

另一方面，

scoped_thread 取得了 thread 实例的所有权，因此也控制了它的生命周期。每当您想拥有要等待的线程时，您都会使用它，例如作为数据成员。

最终，你使用哪个是一个语义问题:你是想在别人拥有的线程上等待(然后你还必须确保没有生命周期问题)，还是你想要一个线程 对象，当它被销毁时阻塞，你不必先加入它。