分离线程然后让它超出范围（并且仍然运行）是否安全？

Question

我有以下代码，我认为它工作正常（请原谅 silly/contrived 示例）。

void run_thread()
{
    std::thread t([]{
        while(true)
        {
            // keep getting chars... to stop peoples eye's hurting : )
            char c = getchar();
        }
    });

    t.detach(); // Detach thread

    // thread goes out of scope here - but is it ok because its detached??
}

int main()
{
     run_thread();    

    // Wait here forever
    while (true) {;}
}

但重读后，我对它产生了疑问。线程 t 超出范围。我现在不记得在你调用 detach() 之后这样做是否安全......我想是的，但正如我所说，我有一个挥之不去的疑问。谁能确认这是否是 good/bad 练习？

Answer 1

这样的用法是detach的点

Answer 2

是的，在你的代码中是安全的。但它没有任何意义。 main 函数将利用 CPU 并且线程函数将获得更少的 CPU 时间。您可以附加到永久线程并达到类似的行为：run_thread 永远不会退出，因此 main 永远不会退出。

void run_thread()
{
    std::thread t([]{
        while(true){/* also run forever */;}
    });

    // Wait here forever
    t.attach();
}

int main()
{
     run_thread();    
}

Answer 3

Thread t goes out of scope. I can't remember now if it is safe to do this after you have called detach()

你 detach() 因为你想取消实际运行线程与线程对象的关联。因此在 } t 超出范围但实际线程将继续运行直到其指令完成。

如果不是 detach() std::terminate 会在 }

杀死线程

Answer 4

detach 基本上是将 C++ "handle" 的 std::thread 对象实例释放给实际的 OS 线程，从而无法 join稍后发帖。

在大多数情况下，最好将 thread 实例保留在某个全局范围内，以便稍后可以 join 它，例如在退出 main 之前。这样你就可以确保所有线程在主线程之前完成。

例如：

std::thread t; // can be "empty"

void run_thread()
{
    t = std::thread([]{
        while(true)
        {
            // keep getting chars...
            char c = getchar();
        }
    });

}

int main()
{
     run_thread();    

    // Wait here
    std::this_thread::sleep_for(30s);

    // Before exiting wait for the thread to finish
    if (t.joinable())
        t.join();
}

分离线程然后让它超出范围（并且仍然运行）是否安全？

is it safe to detach a thread and then let it go out of scope (and have it still running)?

c++

detach

stdthread

分离线程然后让它超出范围（并且仍然 运行）是否安全？

is it safe to detach a thread and then let it go out of scope (and have it still running)?

c++

detach

stdthread

分离线程然后让它超出范围（并且仍然运行）是否安全？