对于 pthread 的 joinable 和 detached 两种线程模型进行对比

<h1 id="pthread--joinable--detached">pthread 的 joinable 和 detached</h1>
对于多线程程序，在程序开始运行后，会首先建立一个主线程，用于执行程序。在程序执行过程中，可能由于需要，会建立新的线程，用于执行并行操作。这时建立的线程称为子线程。 
除去主线程外，其他所有的线程都属于子线程，为平等关系，即使是由子线程建立的子线程。
在 POSIX Threads 中，有两种线程类型：
<ul>
<li>结合(joinable)：对于结合的线程，主线程需要用<code>join()</code>函数来等待子线程执行完毕获得返回值，并释放资源；</li>
<li>分离(detached)：分离的线程相对而言独立于主线程，不需要主线程等待，会自动释放资源；joinable 的线程可以转换成 detached 的线程，但不能反向转换；</li>
</ul>
尽管一些文章会提到 joinable 线程在除非关机或重启都不会释放资源<a href="#fn:1" class="footnote-ref" role="doc-noteref">1</a>，但是对于目前的操作系统的智能程度，在进程结束后都会被清除资源<a href="#fn:2" class="footnote-ref" role="doc-noteref">2</a>，joinable 线程和 detached 线程的区别在于：
<ul>
<li>主线程是否需要等待线程执行结束</li>
<li>是否需要立即释放资源</li>
</ul>
一个更为直观的类比是，joinable 是类似于常见的 Python 线程模型，创建后开启线程，并且使用 join 来等待所有线程执行完成。当然，如果主线程不需要等待子线程执行结束就可以执行其他任务，也可以不使用 join 。这时效果上类似于 detached 线程模型<a href="#fn:3" class="footnote-ref" role="doc-noteref">3</a>
而 detached 线程模型则很类似于 Go 语言的 goroutine 。子线程执行后，主线程就不再管子线程的事情，完全由子线程自行处理调度问题。（当然， Go 中可以使用 <code>select</code> 和 <code>channel</code> 来实现等待任务执行结束，或者任务之间数据交互）
<h2 id="joinable-">joinable 线程样例</h2>
执行下面的程序，会开启 <code>THREAD_NUM</code> 个线程，并在主线程等待其执行完毕
<pre style="background-color:#fff">#include &lt;pthread.h&gt;
#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;
#include &lt;unistd.h&gt;

#define THREAD_NUM 3

void *thread_function(void *arg) {
 int tid = *(int *)arg;
 for (int i = 0; i &lt; 3; i++) {
 printf(&#34;%d-%d\n&#34;, tid, i);
 sleep(1);
 }
 return NULL;
}

int main(void) {
 pthread_t *threads = malloc(THREAD_NUM * sizeof(pthread_t));

 for (int i = 0; i &lt; THREAD_NUM; ++i) {
 if (pthread_create(&amp;threads[i], NULL, thread_function, &amp;i)) {
 printf(&#34;error creating thread.&#34;);
 abort();
 }
 }

 for (int i = 0; i &lt; THREAD_NUM; ++i) {
 if (pthread_join(threads[i], NULL)) {
 printf(&#34;error join thread.&#34;);
 abort();
 }
 }

 printf(&#34;thread done! \n&#34;);
 return 0;
}
</pre><h2 id="detached-">detached 线程样例</h2>
执行下面的程序，会开启 <code>THREAD_NUM</code> 个线程，并在主线程等待 2 秒（因为子线程需要 3 秒才能输出完毕，因此不会输出所有内容。
detached 线程很适合主线程在无限循环或者在运行很长的服务，同时有很多个需要并行执行的任务（一般不需要将执行信息反馈到创建的线程，当然也可以使用互斥锁等方法来在线程间同步数据）
<pre style="background-color:#fff">#include &lt;pthread.h&gt;
#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;
#include &lt;unistd.h&gt;

#define THREAD_NUM 3

void *thread_function(void *arg) {
 int tid = *(int *)arg;
 for (int i = 0; i &lt; 3; i++) {
 printf(&#34;%d-%d\n&#34;, tid, i);
 sleep(1);
 }
 return NULL;
}

int main(void) {
 pthread_t *threads = malloc(THREAD_NUM * sizeof(pthread_t));

 pthread_attr_t attr;
 pthread_attr_init(&amp;attr);
 pthread_attr_setdetachstate(&amp;attr, PTHREAD_CREATE_DETACHED);

 for (int i = 0; i &lt; THREAD_NUM; ++i) {
 if (pthread_create(&amp;threads[i], &amp;attr, thread_function, &amp;i)) {
 printf(&#34;error creating thread.&#34;);
 abort();
 }
 }

 sleep(2);

 printf(&#34;thread done! \n&#34;);
 exit(0);
}
</pre><h2 id="heading">参考资料</h2>
<section class="footnotes" role="doc-endnotes">
<hr>
<ol>
<li id="fn:1" role="doc-endnote">
<a href="https://www.cnblogs.com/LuckCoder/p/10950583.html">c++11中thread join和detach的区别</a> <a href="#fnref:1" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a>
</li>
<li id="fn:2" role="doc-endnote">
<a href="https://stackoverflow.com/questions/3756882/detached-vs-joinable-posix-threads">Detached vs. Joinable POSIX threads</a> <a href="#fnref:2" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a>
</li>
<li id="fn:3" role="doc-endnote">
<a href="https://www.v2ex.com/t/166537">python threading 一定要 join 吗？</a> <a href="#fnref:3" class="footnote-backref" role="doc-backlink">&#x21a9;&#xfe0e;</a>
</li>
</ol>
</section>

pthread 中 join 和 detach