blocks|key|133211|text|如果您不打算等待线程使用join完成，那么您应该调用detach，但是线程将继续运行，直到它完成，然后终止，而不是让派生线程专门等待它；|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|133212|std::thread(func).detach();+//+It's+done+when+it's+done|code-block|syntax|javascript|133213|detach基本上会释放实现join所需的资源。|133214|如果线程对象结束其生命周期，并且既没有调用join也没有调用detach，这是一个致命的错误；在这种情况下，将调用terminate。|133215|entityMap^0|C|4|Q|6|0|0|0|6|E|4|0|L|4|U|6|1L|9|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|W|8|@$9|X|A|Y|B|C]|$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|M|3|N|5|6|7|11|8|@$9|12|A|13|B|C]|$9|14|A|15|B|C]|$9|16|A|17|B|C]]|D|@]|E|$]]|$1|O|3|-4|5|6|7|18|8|@]|D|@]|E|$]]]|P|$]]

You should call <code>detach</code> if you're not going to wait for the thread to complete with <code>join</code> but the thread instead will just keep running until it's done and then terminate without having the spawner thread waiting for it specifically; e.g.
<pre><code>std::thread(func).detach(); // It's done when it's done
</code></pre>
<code>detach</code> basically will release the resources needed to be able to implement <code>join</code>.
It is a fatal error if a thread object ends its life and neither <code>join</code> nor <code>detach</code> has been called; in this case <code>terminate</code> is invoked.

blocks|key|4639786|text|此答案旨在回答标题中的问题，而不是解释join和detach之间的区别。那么什么时候应该使用std::thread::detach呢？|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4639787|在维护得当的C%2B%2B代码中，根本不应该使用std::thread::detach。程序员必须确保所有创建的线程都正常退出，释放所有获取的资源，并执行其他必要的清理操作。这意味着不能通过调用detach来放弃线程的所有权，因此在所有场景中都应该使用join。|4639788|但是，一些应用程序依赖于旧的、通常不是很好地设计和支持的API，这些API可能包含无限的阻塞函数。将这些函数的调用移动到专用线程中以避免阻塞其他东西是一种常见的做法。没有办法让这样的线程优雅地退出，所以使用join只会导致主线程阻塞。在这种情况下，与分配具有动态存储持续时间的thread对象相比，使用detach可能是一种不那么有害的选择，然后故意泄漏它。|4639789|#include+<LegacyApi.hpp>
#include+<thread>

auto+LegacyApiThreadEntry(void)
{
++++auto+result{NastyBlockingFunction()};
++++//+do+something...
}

int+main()
{
++++::std::thread+legacy_api_thread{&LegacyApiThreadEntry};
++++//+do+something...
++++legacy_api_thread.detach();
++++return+0;
}|code-block|syntax|javascript|4639790|entityMap^0|J|4|O|6|1A|J|0|K|J|2L|6|3E|4|0|2V|4|3U|6|47|6|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|X|8|@$9|Y|A|Z|B|C]|$9|10|A|11|B|C]|$9|12|A|13|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|14|8|@$9|15|A|16|B|C]|$9|17|A|18|B|C]|$9|19|A|1A|B|C]]|D|@]|E|$]]|$1|J|3|K|5|L|7|1B|8|@]|D|@]|E|$M|N]]|$1|O|3|-4|5|6|7|1C|8|@]|D|@]|E|$]]]|P|$]]

This answer is aimed at answering question in the title, rather than explaining the difference between <code>join</code> and <code>detach</code>. So when should <code>std::thread::detach</code> should be used?

In properly maintained C++ code <code>std::thread::detach</code> should not be used at all. Programmer must ensure that all the created threads gracefully exit releasing all the acquired resources and performing other necessary cleanup actions. This implies that giving up ownership of threads by invoking <code>detach</code> is not an option and therefore <code>join</code> should be used in all scenarios.

However some applications rely on old and often not well designed and supported APIs that may contain indefinitely blocking functions. Moving invocations of these functions into a dedicated thread to avoid blocking other stuff is a common practice. There is no way to make such a thread to exit gracefully so use of <code>join</code> will just lead to primary thread blocking. That's a situation when using <code>detach</code> would be a less evil alternative to, say, allocating <code>thread</code> object with dynamic storage duration and then purposely leaking it.

<pre><code>#include &lt;LegacyApi.hpp&gt;
#include &lt;thread&gt;

auto LegacyApiThreadEntry(void)
{
 auto result{NastyBlockingFunction()};
 // do something...
}

int main()
{
 ::std::thread legacy_api_thread{&amp;LegacyApiThreadEntry};
 // do something...
 legacy_api_thread.detach();
 return 0;
}
</code></pre>

blocks|key|4639955|text|也许迭代上面的一个答案是个好主意:当main函数完成并且主线程关闭时，所有的衍生线程要么终止要么挂起。因此，如果你依赖于分离来让后台线程在主线程关闭后继续运行，那么你将会遇到一个惊喜。要查看效果，请尝试执行以下操作。如果您取消对最后一个睡眠调用的注释，则会创建输出文件并将其写为fine。否则就不会：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4639956|#include+<mutex>
#include+<thread>
#include+<iostream>
#include+<fstream>
#include+<array>
#include+<chrono>

using+Ms+=+std::chrono::milliseconds;

std::once_flag+oflag;
std::mutex+mx;
std::mutex+printMx;
int+globalCount{};
std::ofstream+*logfile;
void+do_one_time_task()+{
++++//printMx.lock();
++++//std::cout<<"I+am+in+thread+with+thread+id:+"<<+std::this_thread::get_id()+<<+std::endl;
++++//printMx.unlock();
++++std::call_once(oflag,+[&]()+{
++++//++std::cout+<<+"Called+once+by+thread:+"+<<+std::this_thread::get_id()+<<+std::endl;+
++++//++std::cout<<"Initialized+globalCount+to+3\n";
++++++++globalCount+=+3;
++++++++logfile+=+new+std::ofstream("testlog.txt");
++++++++//logfile.open("testlog.txt");
++++++++});
++++std::this_thread::sleep_for(Ms(100));
++++//+some+more+here
++++for(int+i=0;+i<10;+%2B%2Bi){++++
++++++++mx.lock();
++++++++%2B%2BglobalCount;
++++++++*logfile+<<+"thread:+"<<+std::this_thread::get_id()+<<",+globalCount+=+"+<<+globalCount+<<+std::endl;
++++++++std::this_thread::sleep_for(Ms(50));
++++++++mx.unlock();
++++++++std::this_thread::sleep_for(Ms(2));
++++}

++++std::this_thread::sleep_for(Ms(2000));
++++std::call_once(oflag,+[&]()+{
++++++++//std::cout+<<+"Called+once+by+thread:+"+<<+std::this_thread::get_id()+<<+std::endl;
++++++++//std::cout+<<+"closing+logfile:\n";
++++++++logfile->close();
++++++++});

}

int+main()
{
++++std::array<std::thread,+5>+thArray;
++++for+(int+i+=+0;+i+<+5;+%2B%2Bi)
++++++++thArray[i]+=+std::thread(do_one_time_task);

++++for+(int+i+=+0;+i+<+5;+%2B%2Bi)
++++++++thArray[i].detach();

++++//std::this_thread::sleep_for(Ms(5000));
++++std::cout+<<+"Main:+globalCount+=+"+<<+globalCount+<<+std::endl;

++++return+0;
}|code-block|syntax|javascript|4639957|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Maybe it is good idea to iterate what was mentioned in one of the answers above: When the main function is finished and main thread is closing, all spawn threads either will be terminated or suspended. So, if you are relying on detach to have a background thread continue running after the main thread is shutdown, you are in for a surprise. To see the effect try the following. If you uncomment the last sleep call, then the output file will be created and written to fine. Otherwise not:
<pre><code>#include &lt;mutex&gt;
#include &lt;thread&gt;
#include &lt;iostream&gt;
#include &lt;fstream&gt;
#include &lt;array&gt;
#include &lt;chrono&gt;

using Ms = std::chrono::milliseconds;

std::once_flag oflag;
std::mutex mx;
std::mutex printMx;
int globalCount{};
std::ofstream *logfile;
void do_one_time_task() {
 //printMx.lock();
 //std::cout&lt;&lt;&quot;I am in thread with thread id: &quot;&lt;&lt; std::this_thread::get_id() &lt;&lt; std::endl;
 //printMx.unlock();
 std::call_once(oflag, [&amp;]() {
 // std::cout &lt;&lt; &quot;Called once by thread: &quot; &lt;&lt; std::this_thread::get_id() &lt;&lt; std::endl; 
 // std::cout&lt;&lt;&quot;Initialized globalCount to 3\n&quot;;
 globalCount = 3;
 logfile = new std::ofstream(&quot;testlog.txt&quot;);
 //logfile.open(&quot;testlog.txt&quot;);
 });
 std::this_thread::sleep_for(Ms(100));
 // some more here
 for(int i=0; i&lt;10; ++i){ 
 mx.lock();
 ++globalCount;
 *logfile &lt;&lt; &quot;thread: &quot;&lt;&lt; std::this_thread::get_id() &lt;&lt;&quot;, globalCount = &quot; &lt;&lt; globalCount &lt;&lt; std::endl;
 std::this_thread::sleep_for(Ms(50));
 mx.unlock();
 std::this_thread::sleep_for(Ms(2));
 }

 std::this_thread::sleep_for(Ms(2000));
 std::call_once(oflag, [&amp;]() {
 //std::cout &lt;&lt; &quot;Called once by thread: &quot; &lt;&lt; std::this_thread::get_id() &lt;&lt; std::endl;
 //std::cout &lt;&lt; &quot;closing logfile:\n&quot;;
 logfile-&gt;close();
 });

}

int main()
{
 std::array&lt;std::thread, 5&gt; thArray;
 for (int i = 0; i &lt; 5; ++i)
 thArray[i] = std::thread(do_one_time_task);

 for (int i = 0; i &lt; 5; ++i)
 thArray[i].detach();

 //std::this_thread::sleep_for(Ms(5000));
 std::cout &lt;&lt; &quot;Main: globalCount = &quot; &lt;&lt; globalCount &lt;&lt; std::endl;

 return 0;
}
</code></pre>

Sometime I have to use <code>std::thread</code> to speed up my application. I also know <code>join()</code> waits until a thread completes. This is easy to understand, but what's the difference between calling <code>detach()</code> and not calling it?

I thought that without <code>detach()</code>, the thread's method will work using a thread independently.

Not detaching:

<pre><code>void Someclass::Somefunction() {
 //...

 std::thread t([ ] {
 printf("thread called without detach");
 });

 //some code here
}
</code></pre>

Calling with detaching:

<pre><code>void Someclass::Somefunction() {
 //...

 std::thread t([ ] {
 printf("thread called with detach");
 });

 t.detach();

 //some code here
}
</code></pre>

When should I use std::thread::detach?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

有时我不得不使用std::thread来加速我应用程序。我还知道join()会一直等到线程完成。这很容易理解，但是调用detach()和不调用它有什么区别呢？我认为如果没有detach()，线程的方法将独立地使用线程工作。不分离：void Someclass::Somefunction() {    //...    ...

问什么时候应该使用std::thread::detach？
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问什么时候应该使用std::thread::detach？EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问什么时候应该使用std::thread::detach？
EN