A thread’s execution ends in exactly one of four ways:

#include <pthread.h>

void pthread_exit(void *retval);
/* Never returns */

pthread_exit() terminates the calling thread. The retval argument specifies the thread’s “return value”, which another thread can collect using pthread_join().

Special case — main thread: If the main thread calls pthread_exit() instead of return or exit(), the main thread terminates but the other threads in the process continue executing. The process stays alive until all threads have finished. This is a very useful pattern when you want to fire off worker threads and not block the main thread waiting for them.

This example demonstrates the difference between using return and pthread_exit(), and shows that calling pthread_exit() from main() lets other threads finish.

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

static void *slow_worker(void *arg)
{
    int id = (int)(intptr_t) arg;
    printf("Worker %d: started\n", id);
    sleep(2);  /* simulate work */
    printf("Worker %d: finished\n", id);
    return (void *)(intptr_t) id;  /* return thread number as exit code */
}

int main(void)
{
    pthread_t t1, t2;

    pthread_create(&t1, NULL, slow_worker, (void *)(intptr_t) 1);
    pthread_create(&t2, NULL, slow_worker, (void *)(intptr_t) 2);

    printf("Main: threads created, main will now exit via pthread_exit()\n");
    printf("Main: workers will still finish!\n");

    /*
     * pthread_exit() in main — does NOT kill the workers.
     * The process stays alive until t1 and t2 both finish.
     *
     * If we used exit(0) or return 0 here, workers would be killed!
     */
    pthread_exit(NULL);

    /* Code below is never reached */
    printf("This line is never printed.\n");
    return 0;
}

Expected output:

Main: threads created, main will now exit via pthread_exit()
Main: workers will still finish!
Worker 1: started
Worker 2: started
Worker 1: finished
Worker 2: finished

Notice: the main thread exits early but the workers complete. If you change pthread_exit(NULL) to exit(0) or return 0, the workers would be killed before they print “finished”.

This example illustrates what NOT to do — returning a pointer to a local (stack) variable. The code compiles but has undefined behaviour.

/* compile: gcc -pthread -o stack_danger stack_danger.c
   WARNING: This demonstrates a BUG — undefined behaviour */
#include <stdio.h>
#include <pthread.h>

/* WRONG — returns pointer to local variable */
static void *bad_thread(void *arg)
{
    int local_result = 42;  /* on the STACK */

    /* DANGEROUS: stack is freed when thread exits! */
    return &local_result;   /* BUG: dangling pointer */
}

/* RIGHT — returns heap-allocated value */
static void *good_thread(void *arg)
{
    int *result = malloc(sizeof(int));   /* on the HEAP — safe */
    *result = 42;
    return result;   /* caller must free() this */
}

int main(void)
{
    pthread_t t;
    void *res;

    /* WRONG way */
    pthread_create(&t, NULL, bad_thread, NULL);
    pthread_join(t, &res);
    /* res now points to freed stack memory — undefined behaviour */
    printf("bad_thread result (UNDEFINED): %d\n", *(int *)res);

    /* RIGHT way */
    pthread_create(&t, NULL, good_thread, NULL);
    pthread_join(t, &res);
    printf("good_thread result: %d\n", *(int *)res);
    free(res);   /* we own the heap allocation now */

    return 0;
}

The bad_thread example may appear to work sometimes (by luck), but it is a bug. Always use heap allocation or a simple integer cast for thread return values.