This is one of the most surprising behaviours in POSIX threading: when a multithreaded process calls fork(), only the calling thread is replicated in the child process. All other threads simply vanish in the child — no cleanup, no destructors, no handlers.

The dangerous part: Even though Threads A and C vanish in the child, their effects remain:

• Global variables are inherited as-is (copied from parent’s memory).
• Mutexes and condition variables are preserved in whatever state they were in at fork time.
• If Thread A was in the middle of updating a data structure and had locked a mutex, the child inherits that locked mutex — but Thread A (the owner) no longer exists. The child is now deadlocked.
• Thread-specific data destructors and cleanup handlers are NOT called for the vanished threads → potential memory leaks in the child.

When any thread calls one of the exec() family functions, the calling program is completely replaced:

• All threads except the one that called exec() vanish immediately.
• No thread-specific data destructors are called.
• No cleanup handlers are executed.
• All process-private mutexes and condition variables disappear (they were in the old process image).
• After exec(), the remaining (new) thread’s ID is unspecified — it starts fresh.

When any thread calls exit() (or the main thread does a return), all threads immediately vanish:

• No thread-specific data destructors are called.
• No cleanup handlers are executed.
• Any threads still running are abruptly terminated.

For programs that must use fork() without immediately calling exec(), Pthreads provides pthread_atfork() to register cleanup handlers that run around the fork.

#include <pthread.h>

int pthread_atfork(void (*prepare)(void),
                   void (*parent)(void),
                   void (*child)(void));
/* Returns 0 on success, positive error number on error */

/* prepare: called in PARENT, BEFORE fork() creates the child.
 *          Run in REVERSE order of registration.
 *          Purpose: acquire all mutexes → ensure clean state.
 *
 * parent:  called in PARENT, AFTER fork() returns.
 *          Run in FORWARD order of registration.
 *          Purpose: release the mutexes acquired in prepare.
 *
 * child:   called in CHILD, AFTER fork() returns.
 *          Run in FORWARD order of registration.
 *          Purpose: release/reinitialise mutexes for child use.
 */

The key insight: The prepare handler runs just before fork, so it can lock all mutexes to ensure no other thread is in the middle of a critical section when the fork happens. After fork, both parent and child handlers unlock (or reinitialise) those mutexes.

This example demonstrates the dangerous scenario: a worker thread holds a mutex when fork() is called from another thread. The child process inherits the locked mutex with no thread to unlock it.

/*
 * ep_fork_mutex_danger.c — Demonstrate mutex deadlock risk after fork()
 * Compile: gcc -o ep_fork_mutex_danger ep_fork_mutex_danger.c -lpthread
 *
 * WARNING: This program intentionally creates a situation that can deadlock.
 * It is an educational demonstration of what NOT to do.
 */
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>

static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
static volatile int data = 0;

/* Worker thread — holds the mutex for 3 seconds */
void *worker(void *arg)
{
    printf("[Worker] Acquiring mutex and sleeping (simulating long critical section)\n");
    pthread_mutex_lock(&lock);
    data = 42;       /* updating shared data */
    sleep(3);        /* simulate work — mutex held during this time */
    data = 100;
    printf("[Worker] Releasing mutex, data = %d\n", data);
    pthread_mutex_unlock(&lock);
    return NULL;
}

int main(void)
{
    pthread_t tid;
    pid_t child_pid;

    pthread_create(&tid, NULL, worker, NULL);

    /* Give worker time to acquire the mutex */
    sleep(1);

    printf("[Main] Calling fork() while worker holds the mutex...\n");
    child_pid = fork();

    if (child_pid == 0) {
        /* CHILD PROCESS — only this thread runs here.
         * The worker thread VANISHED. But the mutex is still LOCKED.
         * If we try to lock it, we deadlock. */
        printf("[Child PID %d] Trying to lock the mutex...\n", getpid());

        /* Use trylock to avoid permanently hanging (for demo purposes) */
        int ret = pthread_mutex_trylock(&lock);
        if (ret == 0) {
            printf("[Child] Mutex was unlocked (lucky!), data = %d\n", data);
            pthread_mutex_unlock(&lock);
        } else {
            printf("[Child] MUTEX IS LOCKED and no one can unlock it! "
                   "Deadlock if we call lock().\n");
            printf("[Child] data = %d (may be inconsistent)\n", data);
        }
        /* Safe pattern: exec() immediately after fork() */
        /* execlp("echo", "echo", "child exec done", NULL); */
        exit(0);
    } else {
        /* PARENT */
        waitpid(child_pid, NULL, 0);
        pthread_join(tid, NULL);
        printf("[Main] Done. This demonstrates the fork() + mutex danger.\n");
    }
    return 0;
}

This example correctly uses pthread_atfork() to acquire all mutexes before fork and reinitialise them cleanly in the child.

/*
 * ep_atfork_safe.c — Safe fork() using pthread_atfork() handlers
 * Compile: gcc -o ep_atfork_safe ep_atfork_safe.c -lpthread
 */
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>

static pthread_mutex_t data_lock = PTHREAD_MUTEX_INITIALIZER;
static int shared_data = 0;

/* ---- Fork handler: runs in PARENT, BEFORE fork() ---- */
static void prepare_handler(void)
{
    printf("[prepare] Acquiring all mutexes before fork...\n");
    pthread_mutex_lock(&data_lock);
    /* In a real program: lock ALL mutexes to ensure consistent state */
}

/* ---- Fork handler: runs in PARENT, AFTER fork() returns ---- */
static void parent_handler(void)
{
    printf("[parent] Releasing mutexes in parent after fork...\n");
    pthread_mutex_unlock(&data_lock);
}

/* ---- Fork handler: runs in CHILD, AFTER fork() returns ---- */
static void child_handler(void)
{
    printf("[child] Reinitialising mutexes in child process...\n");
    /* REINITIALISE — do NOT just unlock(), because the mutex was
     * locked by a thread in the parent that no longer exists in child.
     * pthread_mutex_init() creates a fresh, unlocked mutex. */
    pthread_mutex_init(&data_lock, NULL);
}

void *worker(void *arg)
{
    for (int i = 0; i < 5; i++) {
        pthread_mutex_lock(&data_lock);
        shared_data++;
        printf("[Worker] Updated shared_data = %d\n", shared_data);
        pthread_mutex_unlock(&data_lock);
        usleep(100000);  /* 100ms */
    }
    return NULL;
}

int main(void)
{
    pthread_t tid;
    pid_t child_pid;

    /* Register fork handlers BEFORE creating threads */
    pthread_atfork(prepare_handler, parent_handler, child_handler);

    pthread_create(&tid, NULL, worker, NULL);
    sleep(1);  /* let worker run a bit */

    printf("[Main] Calling fork()...\n");
    child_pid = fork();

    if (child_pid == 0) {
        /* CHILD — mutex is cleanly reinitialised, safe to use */
        printf("[Child PID %d] Mutex is clean. Accessing shared_data = %d\n",
               getpid(), shared_data);
        pthread_mutex_lock(&data_lock);
        shared_data = 999;
        printf("[Child] Set shared_data = %d (child's own copy)\n",
               shared_data);
        pthread_mutex_unlock(&data_lock);
        exit(0);
    } else {
        waitpid(child_pid, NULL, 0);
        pthread_join(tid, NULL);
        printf("[Main] Parent shared_data = %d (unchanged by child)\n",
               shared_data);
    }
    return 0;
}