At any point in time, a thread is joinable or detached. A joinable thread can be reaped and killed by other
threads. Its memory resources (such as the stack) are not freed until it is reaped by another thread. In
contrast, a detached thread cannot be reaped or killed by other threads. Its memory resources are freed
automatically by the system when it terminates.
By default, threads are created joinable. In order to avoid memory leaks, each joinable thread should either
be explicitly reaped by another thread, or detached by a call to the pthread detach function.
#include <pthread.h>
int pthread_detach(pthread t tid);
returns: 0 if OK, non-zero on error
The pthread detach function detaches the joinable thread tid. Threads can detach themselves by
calling pthread detach with an argument of pthread self().
Even though some of our examples will use joinable threads, there are good reasons to use detached threads
in real programs. For example, a high-performance Web server might create a new peer thread each time
it receives a connection request from a Web browser. Since each connection is handled independently by a
separate thread, it is unnecessary and indeed undesirable for the server to explicitly wait for each peer thread
to terminate. In this case, each peer thread should detach itself before it begins processing the request so
that its memory resources can be reclaimed after it terminates.
摘自《深入理解计算机系统》