#include <pthread.h>

int pthread_join(pthread_t thread, void **retval);

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

Behaviour:

• If the thread has already terminated by the time pthread_join() is called, the function returns immediately.
• If the thread is still running, the calling thread blocks until it finishes.
• The function cleans up the resources associated with the terminated thread (like the stack). Without calling pthread_join() or detaching the thread, these resources are not freed.

This is an important conceptual difference from processes:

However, pthread_join() can only join with a specific thread ID — there is no “join with any thread” equivalent of waitpid(-1, ...). This is intentional: joining with an arbitrary thread could cause a library’s private threads to be accidentally joined by application code, breaking modularity.

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

/* Compute sum of 1..n and return result */
static void *sum_worker(void *arg)
{
    long n = (long)(intptr_t) arg;
    long sum = 0;

    for (long i = 1; i <= n; i++)
        sum += i;

    printf("Worker: sum(1..%ld) = %ld\n", n, sum);

    /* Return sum as void * via cast */
    return (void *)(intptr_t) sum;
}

int main(void)
{
    pthread_t t1, t2;
    void     *res1, *res2;
    int       s;

    /* Create two threads with different arguments */
    s = pthread_create(&t1, NULL, sum_worker, (void *)(intptr_t) 100);
    if (s != 0) { fprintf(stderr, "create t1 failed\n"); exit(1); }

    s = pthread_create(&t2, NULL, sum_worker, (void *)(intptr_t) 200);
    if (s != 0) { fprintf(stderr, "create t2 failed\n"); exit(1); }

    /* Wait for both threads and collect return values */
    pthread_join(t1, &res1);
    pthread_join(t2, &res2);

    printf("Main: t1 returned %ld\n", (long)(intptr_t) res1);
    printf("Main: t2 returned %ld\n", (long)(intptr_t) res2);
    printf("Main: grand total = %ld\n",
           (long)(intptr_t)res1 + (long)(intptr_t)res2);

    return 0;
}

Expected output:

Worker: sum(1..100) = 5050
Worker: sum(1..200) = 20100
Main: t1 returned 5050
Main: t2 returned 20100
Main: grand total = 25150

This example shows the difference between a correctly joined thread and an un-joined one, and demonstrates how failing to join eventually causes thread creation to fail.

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

static void *do_nothing(void *arg) { return NULL; }

int main(void)
{
    pthread_t tid;
    int s, created = 0;

    /*
     * Create threads WITHOUT joining — they become zombies.
     * Eventually pthread_create() will fail.
     */
    while (1) {
        s = pthread_create(&tid, NULL, do_nothing, NULL);
        if (s != 0) {
            printf("pthread_create failed after %d threads: %s\n",
                   created, strerror(s));
            break;
        }
        /* NOTE: not calling pthread_join() — threads become zombies */
        created++;

        if (created % 100 == 0)
            printf("Created %d zombie threads so far...\n", created);
    }

    /*
     * To fix this, either:
     *   pthread_join(tid, NULL);   after each create, OR
     *   use detached threads       (Part 7)
     */
    return 0;
}

Run this to see the system run out of thread slots. In practice you would fix this by either calling pthread_join() or creating detached threads (covered in Part 7).