By default, every thread created by pthread_create() is joinable. A joinable thread must be joined after it terminates — otherwise it becomes a zombie thread.

A thread can also be in the detached state. When a detached thread terminates, the system automatically frees all its resources. No other thread needs to (or can) call pthread_join() for it.

#include <pthread.h>

int pthread_detach(pthread_t thread);

/* Returns: 0 on success, positive error number on failure */

Call this after creating a thread when you decide you don’t need to join it. You can also call it from inside the thread itself to make it self-detaching:

/* Inside the thread's start function */
pthread_detach(pthread_self());

Instead of creating a joinable thread and then calling pthread_detach(), you can set the thread attribute to detached before creation. This avoids a race condition where the thread might finish before you call pthread_detach().

The steps are:

1. Declare a pthread_attr_t variable
2. Initialise it with pthread_attr_init()
3. Set detached state with pthread_attr_setdetachstate()
4. Pass the attribute to pthread_create()
5. Destroy the attribute with pthread_attr_destroy()

pthread_t      thr;
pthread_attr_t attr;
int            s;

s = pthread_attr_init(&attr);           /* (2) initialise with defaults */
if (s != 0) { /* handle error */ }

s = pthread_attr_setdetachstate(&attr,  /* (3) set detached */
                                PTHREAD_CREATE_DETACHED);
if (s != 0) { /* handle error */ }

s = pthread_create(&thr, &attr, start_fn, arg);  /* (4) create */
if (s != 0) { /* handle error */ }

s = pthread_attr_destroy(&attr);        /* (5) clean up attr */
if (s != 0) { /* handle error */ }

A common use-case: a logging thread that runs in the background and you don’t need to join it. It detaches itself on startup.

/* compile: gcc -pthread -o detach_logger detach_logger.c */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>

static void *logger_thread(void *arg)
{
    /* Detach self — no one needs to join us */
    pthread_detach(pthread_self());

    int count = (int)(intptr_t) arg;

    for (int i = 0; i < count; i++) {
        printf("[LOG] Message %d from background logger\n", i + 1);
        sleep(1);
    }

    printf("[LOG] Logger done. Exiting.\n");
    return NULL;   /* resources freed automatically */
}

int main(void)
{
    pthread_t tid;
    int s;

    /* Create logger thread — we will NOT call pthread_join() */
    s = pthread_create(&tid, NULL, logger_thread, (void *)(intptr_t) 3);
    if (s != 0) { fprintf(stderr, "create failed\n"); exit(1); }

    printf("Main: logger started (detached), continuing other work...\n");

    /* Main does its own work */
    for (int i = 0; i < 3; i++) {
        printf("Main: working... step %d\n", i + 1);
        sleep(1);
    }

    printf("Main: done. Calling pthread_exit so logger can finish.\n");

    /*
     * Use pthread_exit() so the logger thread can finish.
     * If we called exit() or return here, the logger would be killed.
     */
    pthread_exit(NULL);
}

This is the TLPI Listing 29-2 pattern — creating a detached thread using pthread_attr_t at creation time.

/* compile: gcc -pthread -o detach_attr detach_attr.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>

static void *background_worker(void *arg)
{
    int id = (int)(intptr_t) arg;
    printf("Background worker %d: running\n", id);
    sleep(2);
    printf("Background worker %d: done (will self-cleanup)\n", id);
    return NULL;
}

int main(void)
{
    pthread_t      thr;
    pthread_attr_t attr;
    int            s;

    /* Step 1: Initialise attribute object */
    s = pthread_attr_init(&attr);
    if (s != 0) { fprintf(stderr, "attr_init: %s\n", strerror(s)); exit(1); }

    /* Step 2: Set detached state */
    s = pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
    if (s != 0) { fprintf(stderr, "setdetachstate: %s\n", strerror(s)); exit(1); }

    /* Step 3: Create thread with the attribute */
    s = pthread_create(&thr, &attr, background_worker, (void *)(intptr_t) 1);
    if (s != 0) { fprintf(stderr, "create: %s\n", strerror(s)); exit(1); }

    /* Step 4: Destroy the attribute — no longer needed */
    s = pthread_attr_destroy(&attr);
    if (s != 0) { fprintf(stderr, "attr_destroy: %s\n", strerror(s)); exit(1); }

    printf("Main: detached thread created, no need to join.\n");

    /* Try to join a detached thread — should fail */
    s = pthread_join(thr, NULL);
    if (s != 0)
        printf("Main: pthread_join failed as expected: %s\n", strerror(s));

    /* Give background thread time to print */
    pthread_exit(NULL);
    return 0;
}

You should see: pthread_join failed as expected: Invalid argument (EINVAL) because you cannot join a detached thread.