Lesson 12advancedThreads

POSIX Threads

Introduction to multi-threaded programming with pthreads. Covers thread creation, exit and return values, cleanup handlers, join, pthread_once, parallel partial sum, race conditions, and combining threads with other IPC mechanisms like FIFOs.

pthreadpthread_createpthread_jointhreadsrace-condition

Prerequisites:02. Process Creation with fork()

Creating Threads

The basics of pthread_create — spawning a thread with a function pointer and argument.

01-pthread_create.c68 lines

/*
 * 01-pthread_create.c — Creating your first thread
 *
 * Demonstrates: pthread_create() and pthread_exit()
 * Key concepts: Thread vs process, pthread_self(), shared address space
 * Compile: gcc -o thread1 01-pthread_create.c -lpthread
 * Run:     ./thread1
 *
 * Note: Both the main thread and the new thread run my_func concurrently.
 *       The interleaved output shows real parallelism.
 */

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>   // for pthread_create(), pthread_exit(), pthread_self()
#include <unistd.h>    // for getpid(), sleep()
#include <time.h>      // for time() (seeding rand)

// Thread function prototype
void* my_func(void *arg);

int main() {
    printf("\n");
    printf("========================================\n");
    printf("  pthread_create — Your First Thread\n");
    printf("========================================\n\n");
    pthread_t thread_data;
    int a = 1;  // Value passed to thread
    int status;

    // Seed random number generator
    srand((unsigned) time(NULL));

    // Create a new thread running my_func, passing a pointer to 'a'
   /*
   pthread_create(&thread_data, NULL, my_func, (void *)&a)
&thread_data: The thread ID is stored here.
NULL: Using default thread attributes.
my_func: Function executed by the thread.
(void *)&a: The argument passed to the thread (a pointer to a).*/
    printf("[Main] Creating a new thread...\n");
    status = pthread_create(&thread_data, NULL, my_func, (void *) &a);
    if (status != 0) {
        fputs("[Main] ERROR: pthread_create failed!\n", stderr);
        exit(EXIT_FAILURE);
    }
    printf("[Main] Thread created (ID: %lu). Now main also calls my_func.\n", (unsigned long)thread_data);
    printf("[Main] Watch the interleaved output — both threads run concurrently!\n\n");

    // Main thread also runs my_func (simulate concurrency)
    my_func((void *)&a);
    puts("This line is never reached because both threads call pthread_exit");
    return EXIT_SUCCESS;
}

void* my_func(void *arg) {
    int i;
    int *val = (int *) arg;
    // Loop 5 times, printing process and thread info
    for (i = 0; i < 5; i++) {
        printf("[Thread %lu] PID=%d, iteration %d/5 (val=%d)\n",
               (unsigned long) pthread_self(), getpid(), i + 1, *val);
        sleep(rand() % 3); // Sleep for a random time between 0-2 seconds
    }
    // Exit the thread
    pthread_exit(NULL);
}

/*
 * 01-pthread_create.c — Creating your first thread
 *
 * Demonstrates: pthread_create() and pthread_exit()
 * Key concepts: Thread vs process, pthread_self(), shared address space
 * Compile: gcc -o thread1 01-pthread_create.c -lpthread
 * Run:     ./thread1
 *
 * Note: Both the main thread and the new thread run my_func concurrently.
 *       The interleaved output shows real parallelism.
 */

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>   // for pthread_create(), pthread_exit(), pthread_self()
#include <unistd.h>    // for getpid(), sleep()
#include <time.h>      // for time() (seeding rand)

// Thread function prototype
void* my_func(void *arg);

int main() {
    printf("\n");
    printf("========================================\n");
    printf("  pthread_create — Your First Thread\n");
    printf("========================================\n\n");
    pthread_t thread_data;
    int a = 1;  // Value passed to thread
    int status;

// Seed random number generator
    srand((unsigned) time(NULL));

// Create a new thread running my_func, passing a pointer to 'a'
   /*
   pthread_create(&thread_data, NULL, my_func, (void *)&a)
&thread_data: The thread ID is stored here.
NULL: Using default thread attributes.
my_func: Function executed by the thread.
(void *)&a: The argument passed to the thread (a pointer to a).*/
    printf("[Main] Creating a new thread...\n");
    status = pthread_create(&thread_data, NULL, my_func, (void *) &a);
    if (status != 0) {
        fputs("[Main] ERROR: pthread_create failed!\n", stderr);
        exit(EXIT_FAILURE);
    }
    printf("[Main] Thread created (ID: %lu). Now main also calls my_func.\n", (unsigned long)thread_data);
    printf("[Main] Watch the interleaved output — both threads run concurrently!\n\n");

// Main thread also runs my_func (simulate concurrency)
    my_func((void *)&a);
    puts("This line is never reached because both threads call pthread_exit");
    return EXIT_SUCCESS;
}

void* my_func(void *arg) {
    int i;
    int *val = (int *) arg;
    // Loop 5 times, printing process and thread info
    for (i = 0; i < 5; i++) {
        printf("[Thread %lu] PID=%d, iteration %d/5 (val=%d)\n",
               (unsigned long) pthread_self(), getpid(), i + 1, *val);
        sleep(rand() % 3); // Sleep for a random time between 0-2 seconds
    }
    // Exit the thread
    pthread_exit(NULL);
}

Editing — changes are local only

Expected Outputclick Run to execute live

[Program timed out after 5 seconds]

Thread Exit with Return Values

Using pthread_exit to return a value from a thread, collected by pthread_join.

02-pthread_exit.c81 lines

/*
 * 02-pthread_exit.c — pthread_exit with return values
 *
 * Key concepts: pthread_exit, returning data from threads, void* return
 * Compile: gcc -o exit 02-pthread_exit.c -lpthread
 * Run:     ./prog
 */
// File: pthread_ret_val.c
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <time.h>

// Thread function prototype
void* my_func(void *arg);

int main() {
    printf("\n");
    printf("========================================\n");
    printf("  pthread_exit — Return Values\n");
    printf("========================================\n\n");
    pthread_t thread_id;
    int a[5] = {17, 38, 79, 3879, 0}; // Data for the thread
    int i;
    int *ret_val;
    int status;

    srand((unsigned) time(NULL));

    printf("[Main] Input array: ");
    for (i = 0; a[i] != 0; i++) printf("%d ", a[i]);
    printf("\n\n");

    // Create a thread passing array 'a'
    printf("[Main] Creating thread to negate all values...\n");
    status = pthread_create(&thread_id, NULL, my_func, a);
    if (status != 0) {
        fputs("[Main] ERROR: pthread_create failed!\n", stderr);
        exit(EXIT_FAILURE);
    }
    // Wait for the thread to finish and collect its return value
    printf("[Main] Waiting for thread to finish (pthread_join)...\n");
    pthread_join(thread_id, (void **) &ret_val);

    // Print the returned values
    printf("\n[Main] Thread finished! Returned array: ");
    for (i = 0; ret_val[i] != 0; i++) {
        printf("%d ", ret_val[i]);
    }
    printf("\n[Main] The thread allocated memory, returned it via pthread_exit, and main read it via pthread_join.\n");

    free(ret_val);
    return EXIT_SUCCESS;
}

void* my_func(void *arg) {
    int i, argc;
    int *params = (int *) arg;
    int *ret_val;

    printf("[Thread] Received input: ");
    for (i = 0; params[i] != 0; i++)
        printf("%d ", params[i]);
    printf("\n[Thread] Negating each value...\n");

    argc = i + 1;
    ret_val = (int *) malloc(argc * sizeof(int));
    if (ret_val == NULL) {
        perror("cannot allocate memory");
        exit(EXIT_FAILURE);
    }

    // Create an output array by negating input values
    for (i = 0; i < argc; i++)
        ret_val[i] = -params[i];

    // Exit the thread, returning the output array
    pthread_exit(ret_val);
}

/*
 * 02-pthread_exit.c — pthread_exit with return values
 *
 * Key concepts: pthread_exit, returning data from threads, void* return
 * Compile: gcc -o exit 02-pthread_exit.c -lpthread
 * Run:     ./prog
 */
// File: pthread_ret_val.c
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <time.h>

// Thread function prototype
void* my_func(void *arg);

int main() {
    printf("\n");
    printf("========================================\n");
    printf("  pthread_exit — Return Values\n");
    printf("========================================\n\n");
    pthread_t thread_id;
    int a[5] = {17, 38, 79, 3879, 0}; // Data for the thread
    int i;
    int *ret_val;
    int status;

srand((unsigned) time(NULL));

printf("[Main] Input array: ");
    for (i = 0; a[i] != 0; i++) printf("%d ", a[i]);
    printf("\n\n");

// Create a thread passing array 'a'
    printf("[Main] Creating thread to negate all values...\n");
    status = pthread_create(&thread_id, NULL, my_func, a);
    if (status != 0) {
        fputs("[Main] ERROR: pthread_create failed!\n", stderr);
        exit(EXIT_FAILURE);
    }
    // Wait for the thread to finish and collect its return value
    printf("[Main] Waiting for thread to finish (pthread_join)...\n");
    pthread_join(thread_id, (void **) &ret_val);

// Print the returned values
    printf("\n[Main] Thread finished! Returned array: ");
    for (i = 0; ret_val[i] != 0; i++) {
        printf("%d ", ret_val[i]);
    }
    printf("\n[Main] The thread allocated memory, returned it via pthread_exit, and main read it via pthread_join.\n");

free(ret_val);
    return EXIT_SUCCESS;
}

void* my_func(void *arg) {
    int i, argc;
    int *params = (int *) arg;
    int *ret_val;

printf("[Thread] Received input: ");
    for (i = 0; params[i] != 0; i++)
        printf("%d ", params[i]);
    printf("\n[Thread] Negating each value...\n");

argc = i + 1;
    ret_val = (int *) malloc(argc * sizeof(int));
    if (ret_val == NULL) {
        perror("cannot allocate memory");
        exit(EXIT_FAILURE);
    }

// Create an output array by negating input values
    for (i = 0; i < argc; i++)
        ret_val[i] = -params[i];

// Exit the thread, returning the output array
    pthread_exit(ret_val);
}

Editing — changes are local only

Expected Outputclick Run to execute live

========================================
  pthread_exit — Return Values
========================================

17 38 79 3879 
 -17 -38 -79 -3879

Cleanup Handlers

Registering cleanup handlers with pthread_cleanup_push/pop — they run when a thread is cancelled or exits.

03-pthread_cleanup.c86 lines

/*
 * 03-pthread_cleanup.c — Thread cleanup handlers — pthread_cleanup_push/pop
 *
 * Key concepts: Cleanup handlers run on thread cancellation or exit
 * Compile: gcc -o cleanup 03-pthread_cleanup.c -lpthread
 * Run:     ./cleanup
 */
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <time.h>

void *thread_func(void *parm);
void cleanup_malloc(void *arg);
void cleanup_msg(void *arg);

int main(int argc, char **argv) {
    pthread_t thread;
    int rc;
    srand(time(NULL));

    printf("\n");
    printf("══════════════════════════════════════\n");
    printf("  pthread_cleanup — Cleanup Handlers\n");
    printf("══════════════════════════════════════\n\n");
    printf("[Main] Cleanup handlers are functions that run automatically\n");
    printf("       when a thread is cancelled or calls pthread_exit.\n\n");

    printf("[Main] Creating secondary thread...\n");
    rc = pthread_create(&thread, NULL, thread_func, NULL);
    if (rc) {
        fprintf(stderr, "[Main] ERROR: pthread_create() failed (rc=%d)\n", rc);
        exit(EXIT_FAILURE);
    }

    sleep(2);
    printf("\n[Main] Cancelling the thread with pthread_cancel()...\n");
    printf("[Main] This should trigger the cleanup handlers.\n");
    rc = pthread_cancel(thread);
    sleep(2);
    printf("\n[Main] Finishing. Note: using return instead of pthread_exit —\n");
    printf("       the secondary thread may not finish its cleanup!\n");
    //HERE there might be race condition
    // if we return EXIT_SUCCESS, the main thread will exit before the secondary thread
    // if we use pthread_exit(NULL), the main thread will wait for the secondary thread to finish
    return EXIT_SUCCESS;
    pthread_exit(NULL);
}

void *thread_func(void *parm) {
    printf("[Thread] Started. Registering cleanup handlers...\n");
    char *p = (char *) malloc(10 * sizeof(char));
    pthread_cleanup_push(cleanup_msg, (void *) "thank you, and come again");
    pthread_cleanup_push(cleanup_malloc, (void *) p);
    if (p == NULL) {
        fprintf(stderr, "[Thread] ERROR: malloc failed!\n");
        exit(EXIT_FAILURE);
    }
    printf("[Thread] Cleanup handlers registered (2 handlers on stack).\n");
    printf("[Thread] Running... (will be cancelled by main after ~2 seconds)\n\n");
    while (1) {
        printf("[Thread] Still running...\n");
        if (rand() % 10 < 1)
        //if (1)
        //we WONT be able to cancel the thread
        //if we return NULL,
        //the cleanup handlers will not run
            return NULL; // Will not execute cleanup; use pthread_exit for cleanup handlers to run.
        sleep(1);
    }
    pthread_cleanup_pop(0);
    pthread_cleanup_pop(0);
    return NULL;
}

void cleanup_msg(void *arg) {
    printf("\n  [Cleanup Handler 1] cleanup_msg called!\n");
    printf("  [Cleanup Handler 1] Message: \"%s\"\n", (char *) arg);
}

void cleanup_malloc(void *arg) {
    printf("  [Cleanup Handler 2] cleanup_malloc called — freeing memory.\n");
    free((char *) arg);
}

/*
 * 03-pthread_cleanup.c — Thread cleanup handlers — pthread_cleanup_push/pop
 *
 * Key concepts: Cleanup handlers run on thread cancellation or exit
 * Compile: gcc -o cleanup 03-pthread_cleanup.c -lpthread
 * Run:     ./cleanup
 */
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <time.h>

void *thread_func(void *parm);
void cleanup_malloc(void *arg);
void cleanup_msg(void *arg);

int main(int argc, char **argv) {
    pthread_t thread;
    int rc;
    srand(time(NULL));

printf("\n");
    printf("══════════════════════════════════════\n");
    printf("  pthread_cleanup — Cleanup Handlers\n");
    printf("══════════════════════════════════════\n\n");
    printf("[Main] Cleanup handlers are functions that run automatically\n");
    printf("       when a thread is cancelled or calls pthread_exit.\n\n");

printf("[Main] Creating secondary thread...\n");
    rc = pthread_create(&thread, NULL, thread_func, NULL);
    if (rc) {
        fprintf(stderr, "[Main] ERROR: pthread_create() failed (rc=%d)\n", rc);
        exit(EXIT_FAILURE);
    }

sleep(2);
    printf("\n[Main] Cancelling the thread with pthread_cancel()...\n");
    printf("[Main] This should trigger the cleanup handlers.\n");
    rc = pthread_cancel(thread);
    sleep(2);
    printf("\n[Main] Finishing. Note: using return instead of pthread_exit —\n");
    printf("       the secondary thread may not finish its cleanup!\n");
    //HERE there might be race condition
    // if we return EXIT_SUCCESS, the main thread will exit before the secondary thread
    // if we use pthread_exit(NULL), the main thread will wait for the secondary thread to finish
    return EXIT_SUCCESS;
    pthread_exit(NULL);
}

void *thread_func(void *parm) {
    printf("[Thread] Started. Registering cleanup handlers...\n");
    char *p = (char *) malloc(10 * sizeof(char));
    pthread_cleanup_push(cleanup_msg, (void *) "thank you, and come again");
    pthread_cleanup_push(cleanup_malloc, (void *) p);
    if (p == NULL) {
        fprintf(stderr, "[Thread] ERROR: malloc failed!\n");
        exit(EXIT_FAILURE);
    }
    printf("[Thread] Cleanup handlers registered (2 handlers on stack).\n");
    printf("[Thread] Running... (will be cancelled by main after ~2 seconds)\n\n");
    while (1) {
        printf("[Thread] Still running...\n");
        if (rand() % 10 < 1)
        //if (1)
        //we WONT be able to cancel the thread
        //if we return NULL,
        //the cleanup handlers will not run
            return NULL; // Will not execute cleanup; use pthread_exit for cleanup handlers to run.
        sleep(1);
    }
    pthread_cleanup_pop(0);
    pthread_cleanup_pop(0);
    return NULL;
}

void cleanup_msg(void *arg) {
    printf("\n  [Cleanup Handler 1] cleanup_msg called!\n");
    printf("  [Cleanup Handler 1] Message: \"%s\"\n", (char *) arg);
}

void cleanup_malloc(void *arg) {
    printf("  [Cleanup Handler 2] cleanup_malloc called — freeing memory.\n");
    free((char *) arg);
}

Editing — changes are local only

Joining Threads

Waiting for threads to complete with pthread_join and retrieving their return values.

04-pthread_join.c85 lines

/*
 * 04-pthread_join.c — Joining threads and shared data races
 *
 * Demonstrates: pthread_join() to wait for threads, shared global variable
 * Key concepts: join blocks until thread finishes, race condition on counter
 * Compile: gcc -Wall -o join 04-pthread_join.c -lpthread
 * Run:     ./join
 *
 * WARNING: The counter increment is NOT thread-safe (no mutex).
 *          Final value should be 50 (5 threads * 10 increments) but might not be!
 *          This is intentional — see lesson 13 for the fix with mutexes.
 */

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>   // for pthread_create(), pthread_join(), pthread_exit()
#include <unistd.h>    // for sleep()
#include <time.h>

// Global counter — shared across ALL threads (this is the race condition)
int counter = 0;

// Thread function prototype
void* increment_counter(void *arg);

int main() {
    printf("\n");
    printf("========================================\n");
    printf("  pthread_join — Waiting for Threads\n");
    printf("========================================\n\n");
    const int num_threads = 5;
    pthread_t threads[num_threads];
    int status, i;

    // Seed the random number generator for demonstration purposes.
    srand((unsigned)time(NULL));

    printf("[Main] Creating %d threads, each will increment a shared counter 10 times.\n", num_threads);
    printf("[Main] NO mutex is used — watch for the race condition!\n\n");

    // Create multiple threads
    for (i = 0; i < num_threads; i++) {
        int *arg = malloc(sizeof(int));
        *arg = i;
        status = pthread_create(&threads[i], NULL, increment_counter, (void *)arg);
        if (status != 0) {
            fprintf(stderr, "[Main] ERROR: pthread_create failed (rc=%d)\n", status);
            exit(EXIT_FAILURE);
        }
        printf("[Main] Created thread %d\n", i);
    }

    printf("\n[Main] All threads created. Calling pthread_join on each...\n\n");

    // Wait for all threads to finish
    for (i = 0; i < num_threads; i++) {
        status = pthread_join(threads[i], NULL);
        if (status != 0) {
            fprintf(stderr, "[Main] ERROR: pthread_join failed (rc=%d)\n", status);
            exit(EXIT_FAILURE);
        }
    }

    int expected = num_threads * 10;
    printf("\n══════════════════════════════════════\n");
    printf("  Results\n");
    printf("══════════════════════════════════════\n");
    printf("  Expected counter: %d (%d threads × 10 increments)\n", expected, num_threads);
    printf("  Actual counter:   %d %s\n", counter, counter != expected ? "← RACE CONDITION!" : "← correct (got lucky this time)");
    return EXIT_SUCCESS;
}

void* increment_counter(void *arg) {
    int id = *((int *) arg);
    // Each thread increments the counter 10 times.
    for (int j = 0; j < 10; j++) {
        // (Warning: This race condition is intentional for demonstration.)
        counter++; 
        printf("[Thread %d] counter++ → %d (NO mutex — race condition possible!)\n", id, counter);
        sleep(rand() % 2);
    }
    // Exit and return (pthread_exit is implicit on function return)
    pthread_exit(NULL);
}

/*
 * 04-pthread_join.c — Joining threads and shared data races
 *
 * Demonstrates: pthread_join() to wait for threads, shared global variable
 * Key concepts: join blocks until thread finishes, race condition on counter
 * Compile: gcc -Wall -o join 04-pthread_join.c -lpthread
 * Run:     ./join
 *
 * WARNING: The counter increment is NOT thread-safe (no mutex).
 *          Final value should be 50 (5 threads * 10 increments) but might not be!
 *          This is intentional — see lesson 13 for the fix with mutexes.
 */

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>   // for pthread_create(), pthread_join(), pthread_exit()
#include <unistd.h>    // for sleep()
#include <time.h>

// Global counter — shared across ALL threads (this is the race condition)
int counter = 0;

// Thread function prototype
void* increment_counter(void *arg);

int main() {
    printf("\n");
    printf("========================================\n");
    printf("  pthread_join — Waiting for Threads\n");
    printf("========================================\n\n");
    const int num_threads = 5;
    pthread_t threads[num_threads];
    int status, i;

// Seed the random number generator for demonstration purposes.
    srand((unsigned)time(NULL));

printf("[Main] Creating %d threads, each will increment a shared counter 10 times.\n", num_threads);
    printf("[Main] NO mutex is used — watch for the race condition!\n\n");

// Create multiple threads
    for (i = 0; i < num_threads; i++) {
        int *arg = malloc(sizeof(int));
        *arg = i;
        status = pthread_create(&threads[i], NULL, increment_counter, (void *)arg);
        if (status != 0) {
            fprintf(stderr, "[Main] ERROR: pthread_create failed (rc=%d)\n", status);
            exit(EXIT_FAILURE);
        }
        printf("[Main] Created thread %d\n", i);
    }

printf("\n[Main] All threads created. Calling pthread_join on each...\n\n");

// Wait for all threads to finish
    for (i = 0; i < num_threads; i++) {
        status = pthread_join(threads[i], NULL);
        if (status != 0) {
            fprintf(stderr, "[Main] ERROR: pthread_join failed (rc=%d)\n", status);
            exit(EXIT_FAILURE);
        }
    }

int expected = num_threads * 10;
    printf("\n══════════════════════════════════════\n");
    printf("  Results\n");
    printf("══════════════════════════════════════\n");
    printf("  Expected counter: %d (%d threads × 10 increments)\n", expected, num_threads);
    printf("  Actual counter:   %d %s\n", counter, counter != expected ? "← RACE CONDITION!" : "← correct (got lucky this time)");
    return EXIT_SUCCESS;
}

void* increment_counter(void *arg) {
    int id = *((int *) arg);
    // Each thread increments the counter 10 times.
    for (int j = 0; j < 10; j++) {
        // (Warning: This race condition is intentional for demonstration.)
        counter++; 
        printf("[Thread %d] counter++ → %d (NO mutex — race condition possible!)\n", id, counter);
        sleep(rand() % 2);
    }
    // Exit and return (pthread_exit is implicit on function return)
    pthread_exit(NULL);
}

Editing — changes are local only

Expected Outputclick Run to execute live

[Program timed out after 5 seconds]

Ping-Pong (Busy Waiting)

Two threads taking turns printing "ping" and "pong" using a shared flag — a deliberate busy-wait anti-pattern.

05-pthread_ping_pong.c75 lines

/*
 * 05-pthread_ping_pong.c — Ping-pong between threads using busy waiting
 *
 * Key concepts: Shared flag, busy waiting (spin loop), thread coordination
 * Compile: gcc -o pingpong 05-pthread_ping_pong.c -lpthread
 * Run:     ./prog
 */
// File: pthread_pingpong.c
// Compile with: gcc -Wall -pthread pthread_pingpong.c -o pthread_pingpong

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
#include <time.h>

// Global variable to indicate whose turn it is (0 or 1)
volatile int turn = 0;

// Thread function prototype
void* pingpong(void *arg);

int main() {
    printf("\n");
    printf("========================================\n");
    printf("  Ping-Pong — Busy-Wait Sync\n");
    printf("========================================\n\n");
    pthread_t threads[2];
    int ids[2] = {0, 1};
    int status;

    // Seed random number generator.
    srand((unsigned) time(NULL));

    printf("[Main] Two threads take turns printing — coordinated via a shared 'turn' flag.\n");
    printf("[Main] Thread 0 = Ping, Thread 1 = Pong. Each waits in a spin loop (busy wait).\n");
    printf("[Main] Note: busy waiting wastes CPU! Better approaches: mutex + cond_wait (lesson 13).\n\n");

    for (int i = 0; i < 2; i++) {
        status = pthread_create(&threads[i], NULL, pingpong, &ids[i]);
        if (status != 0) {
            fprintf(stderr, "[Main] ERROR: pthread_create failed (rc=%d)\n", status);
            exit(EXIT_FAILURE);
        }
    }

    for (int i = 0; i < 2; i++) {
        pthread_join(threads[i], NULL);
    }
    printf("\n[Main] Ping-Pong complete — 5 rounds each, perfectly alternating.\n");
    return EXIT_SUCCESS;
}

void* pingpong(void *arg) {
    int id = *((int *) arg);
    // Each thread will print its message 5 times.
    for (int round = 0; round < 5; round++) {
        // Busy wait until it is this thread's turn.
        while (turn != id) {
            ; // Do nothing
        }

        // Print message: "Ping" or "Pong"
        if (id == 0)
            printf("[Thread 0] Ping! (round %d)\n", round + 1);
        else
            printf("[Thread 1]   Pong! (round %d)\n", round + 1);

        // Let the other thread proceed.
        turn = 1 - id;
        sleep(1); // Simulate work
    }
    pthread_exit(NULL);
}

/*
 * 05-pthread_ping_pong.c — Ping-pong between threads using busy waiting
 *
 * Key concepts: Shared flag, busy waiting (spin loop), thread coordination
 * Compile: gcc -o pingpong 05-pthread_ping_pong.c -lpthread
 * Run:     ./prog
 */
// File: pthread_pingpong.c
// Compile with: gcc -Wall -pthread pthread_pingpong.c -o pthread_pingpong

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
#include <time.h>

// Global variable to indicate whose turn it is (0 or 1)
volatile int turn = 0;

// Thread function prototype
void* pingpong(void *arg);

int main() {
    printf("\n");
    printf("========================================\n");
    printf("  Ping-Pong — Busy-Wait Sync\n");
    printf("========================================\n\n");
    pthread_t threads[2];
    int ids[2] = {0, 1};
    int status;

// Seed random number generator.
    srand((unsigned) time(NULL));

printf("[Main] Two threads take turns printing — coordinated via a shared 'turn' flag.\n");
    printf("[Main] Thread 0 = Ping, Thread 1 = Pong. Each waits in a spin loop (busy wait).\n");
    printf("[Main] Note: busy waiting wastes CPU! Better approaches: mutex + cond_wait (lesson 13).\n\n");

for (int i = 0; i < 2; i++) {
        status = pthread_create(&threads[i], NULL, pingpong, &ids[i]);
        if (status != 0) {
            fprintf(stderr, "[Main] ERROR: pthread_create failed (rc=%d)\n", status);
            exit(EXIT_FAILURE);
        }
    }

for (int i = 0; i < 2; i++) {
        pthread_join(threads[i], NULL);
    }
    printf("\n[Main] Ping-Pong complete — 5 rounds each, perfectly alternating.\n");
    return EXIT_SUCCESS;
}

void* pingpong(void *arg) {
    int id = *((int *) arg);
    // Each thread will print its message 5 times.
    for (int round = 0; round < 5; round++) {
        // Busy wait until it is this thread's turn.
        while (turn != id) {
            ; // Do nothing
        }

// Print message: "Ping" or "Pong"
        if (id == 0)
            printf("[Thread 0] Ping! (round %d)\n", round + 1);
        else
            printf("[Thread 1]   Pong! (round %d)\n", round + 1);

// Let the other thread proceed.
        turn = 1 - id;
        sleep(1); // Simulate work
    }
    pthread_exit(NULL);
}

Editing — changes are local only

Expected Outputclick Run to execute live

[Program timed out after 5 seconds]

pthread_once

Ensuring an initialization function runs exactly once across all threads using pthread_once.

06-pthread-once.c73 lines

/*
 * 06-pthread-once.c — pthread_once — initialization that runs exactly once
 *
 * Key concepts: pthread_once_t, thread-safe one-time init
 * Compile: gcc -o once 06-pthread-once.c -lpthread
 * Run:     ./prog
 */
// File: pthread_once_example.c
// Compile with: gcc -Wall -pthread pthread_once_example.c -o pthread_once_example

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <pthread.h>

void* my_func(void *arg);
void init(); // This function will be called only once

int *arr;
int counter = 0;
pthread_once_t once_control = PTHREAD_ONCE_INIT;

int main() {
    printf("\n");
    printf("========================================\n");
    printf("  pthread_once — One-Time Init\n");
    printf("========================================\n\n");
    pthread_t threads[5];
    int i, status;

    printf("[Main] Creating 5 threads. Each calls pthread_once() to ensure init() runs ONCE.\n");
    printf("[Main] Only the FIRST thread to call pthread_once will execute init().\n\n");

    for (i = 0; i < 5; i++) {
        status = pthread_create(&threads[i], NULL, my_func, NULL);
        if (status != 0) {
            fprintf(stderr, "[Main] ERROR: pthread_create failed\n");
            exit(EXIT_FAILURE);
        }
        printf("[Main] Created thread %d\n", i);
    }

    for (i = 0; i < 5; i++) {
        pthread_join(threads[i], NULL);
    }

    printf("\n[Main] All threads finished. Shared array contents: ");
    for (i = 0; i < counter; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n[Main] init() ran exactly once, even though 5 threads called pthread_once.\n");
    free(arr);
    return EXIT_SUCCESS;
}

void* my_func(void *arg) {
    // Ensure that init() is called exactly once.
    pthread_once(&once_control, init);
    // For demonstration, each thread adds a random number to the shared array.
    arr[counter++] = rand() % 10;
    pthread_exit(NULL);
}

void init() {
    printf("  [init()] This runs EXACTLY ONCE — allocating shared array.\n\n");
    srand(time(NULL));
    arr = (int *) malloc(5 * sizeof(int));
    if (!arr) {
        perror("malloc() failed");
        exit(EXIT_FAILURE);
    }
}

/*
 * 06-pthread-once.c — pthread_once — initialization that runs exactly once
 *
 * Key concepts: pthread_once_t, thread-safe one-time init
 * Compile: gcc -o once 06-pthread-once.c -lpthread
 * Run:     ./prog
 */
// File: pthread_once_example.c
// Compile with: gcc -Wall -pthread pthread_once_example.c -o pthread_once_example

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <pthread.h>

void* my_func(void *arg);
void init(); // This function will be called only once

int *arr;
int counter = 0;
pthread_once_t once_control = PTHREAD_ONCE_INIT;

int main() {
    printf("\n");
    printf("========================================\n");
    printf("  pthread_once — One-Time Init\n");
    printf("========================================\n\n");
    pthread_t threads[5];
    int i, status;

printf("[Main] Creating 5 threads. Each calls pthread_once() to ensure init() runs ONCE.\n");
    printf("[Main] Only the FIRST thread to call pthread_once will execute init().\n\n");

for (i = 0; i < 5; i++) {
        status = pthread_create(&threads[i], NULL, my_func, NULL);
        if (status != 0) {
            fprintf(stderr, "[Main] ERROR: pthread_create failed\n");
            exit(EXIT_FAILURE);
        }
        printf("[Main] Created thread %d\n", i);
    }

for (i = 0; i < 5; i++) {
        pthread_join(threads[i], NULL);
    }

printf("\n[Main] All threads finished. Shared array contents: ");
    for (i = 0; i < counter; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n[Main] init() ran exactly once, even though 5 threads called pthread_once.\n");
    free(arr);
    return EXIT_SUCCESS;
}

void* my_func(void *arg) {
    // Ensure that init() is called exactly once.
    pthread_once(&once_control, init);
    // For demonstration, each thread adds a random number to the shared array.
    arr[counter++] = rand() % 10;
    pthread_exit(NULL);
}

void init() {
    printf("  [init()] This runs EXACTLY ONCE — allocating shared array.\n\n");
    srand(time(NULL));
    arr = (int *) malloc(5 * sizeof(int));
    if (!arr) {
        perror("malloc() failed");
        exit(EXIT_FAILURE);
    }
}

Editing — changes are local only

Expected Outputclick Run to execute live

========================================
  pthread_once — One-Time Init
========================================

In init()
6 7 8 3 3 
Done

Parallel Partial Sum

Splitting an array across threads, each computing a partial sum, then combining results — a real parallelism speedup.

07-partial-sum.c87 lines

/*
 * 07-partial-sum.c — Parallel partial sum — dividing work across threads
 *
 * Key concepts: Thread work partitioning, combining partial results
 * Compile: gcc -o partsum 07-partial-sum.c -lpthread
 * Run:     ./prog
 */
// File: parallel_sum.c
// Compile with: gcc -Wall -pthread parallel_sum.c -o parallel_sum

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

#define NUM_THREADS 4
#define ARRAY_SIZE 20

int arr[ARRAY_SIZE];
int partial_sums[NUM_THREADS]; // each thread stores its partial sum

// Thread function: Each thread computes the sum of a portion of the array.
void* compute_partial_sum(void *arg) {
    int thread_id = *(int *)arg;
    int start = thread_id * (ARRAY_SIZE / NUM_THREADS);
    int end = start + (ARRAY_SIZE / NUM_THREADS);
    int sum = 0;

    printf("[Thread %d] Processing indices %d..%d: ", thread_id, start, end - 1);
    for (int i = start; i < end; i++) {
        printf("%d", arr[i]);
        if (i < end - 1) printf(" + ");
        sum += arr[i];
    }
    printf(" = %d\n", sum);

    partial_sums[thread_id] = sum;
    pthread_exit(NULL);
}

int main() {
    pthread_t threads[NUM_THREADS];
    int thread_ids[NUM_THREADS];
    int status;
    int total_sum = 0;

    // Initialize the array with values 1 to ARRAY_SIZE.
    printf("\n");
    printf("========================================\n");
    printf("  Parallel Partial Sum\n");
    printf("========================================\n\n");
    printf("Initializing array with values: ");
    for (int i = 0; i < ARRAY_SIZE; i++) {
        arr[i] = i + 1;
        printf("%d", arr[i]);
        if (i < ARRAY_SIZE - 1) printf(", ");
    }
    printf("\n\n");

    // Create threads: Each thread computes a part of the sum.
    printf("[Main] Splitting into %d threads (%d elements each)...\n\n", NUM_THREADS, ARRAY_SIZE / NUM_THREADS);
    for (int i = 0; i < NUM_THREADS; i++) {
        thread_ids[i] = i;
        status = pthread_create(&threads[i], NULL, compute_partial_sum, (void *)&thread_ids[i]);
        if (status != 0) {
            fprintf(stderr, "pthread_create failed for thread %d\n", i);
            exit(EXIT_FAILURE);
        }
    }

    // Wait for all threads to finish.
    for (int i = 0; i < NUM_THREADS; i++) {
        pthread_join(threads[i], NULL);
        printf("[Main] Thread %d finished — partial sum = %d\n", i, partial_sums[i]);
    }

    // Calculate the total sum.
    for (int i = 0; i < NUM_THREADS; i++) {
        total_sum += partial_sums[i];
    }

    printf("\n══════════════════════════════════════\n");
    printf("  Total sum = %d", total_sum);
    printf("  (sum of 1..%d = %d × %d / 2 = %d ✓)\n", ARRAY_SIZE, ARRAY_SIZE, ARRAY_SIZE + 1, ARRAY_SIZE * (ARRAY_SIZE + 1) / 2);
    printf("══════════════════════════════════════\n");
    return EXIT_SUCCESS;
}

/*
 * 07-partial-sum.c — Parallel partial sum — dividing work across threads
 *
 * Key concepts: Thread work partitioning, combining partial results
 * Compile: gcc -o partsum 07-partial-sum.c -lpthread
 * Run:     ./prog
 */
// File: parallel_sum.c
// Compile with: gcc -Wall -pthread parallel_sum.c -o parallel_sum

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

#define NUM_THREADS 4
#define ARRAY_SIZE 20

int arr[ARRAY_SIZE];
int partial_sums[NUM_THREADS]; // each thread stores its partial sum

// Thread function: Each thread computes the sum of a portion of the array.
void* compute_partial_sum(void *arg) {
    int thread_id = *(int *)arg;
    int start = thread_id * (ARRAY_SIZE / NUM_THREADS);
    int end = start + (ARRAY_SIZE / NUM_THREADS);
    int sum = 0;

printf("[Thread %d] Processing indices %d..%d: ", thread_id, start, end - 1);
    for (int i = start; i < end; i++) {
        printf("%d", arr[i]);
        if (i < end - 1) printf(" + ");
        sum += arr[i];
    }
    printf(" = %d\n", sum);

partial_sums[thread_id] = sum;
    pthread_exit(NULL);
}

int main() {
    pthread_t threads[NUM_THREADS];
    int thread_ids[NUM_THREADS];
    int status;
    int total_sum = 0;

// Initialize the array with values 1 to ARRAY_SIZE.
    printf("\n");
    printf("========================================\n");
    printf("  Parallel Partial Sum\n");
    printf("========================================\n\n");
    printf("Initializing array with values: ");
    for (int i = 0; i < ARRAY_SIZE; i++) {
        arr[i] = i + 1;
        printf("%d", arr[i]);
        if (i < ARRAY_SIZE - 1) printf(", ");
    }
    printf("\n\n");

// Create threads: Each thread computes a part of the sum.
    printf("[Main] Splitting into %d threads (%d elements each)...\n\n", NUM_THREADS, ARRAY_SIZE / NUM_THREADS);
    for (int i = 0; i < NUM_THREADS; i++) {
        thread_ids[i] = i;
        status = pthread_create(&threads[i], NULL, compute_partial_sum, (void *)&thread_ids[i]);
        if (status != 0) {
            fprintf(stderr, "pthread_create failed for thread %d\n", i);
            exit(EXIT_FAILURE);
        }
    }

// Wait for all threads to finish.
    for (int i = 0; i < NUM_THREADS; i++) {
        pthread_join(threads[i], NULL);
        printf("[Main] Thread %d finished — partial sum = %d\n", i, partial_sums[i]);
    }

// Calculate the total sum.
    for (int i = 0; i < NUM_THREADS; i++) {
        total_sum += partial_sums[i];
    }

printf("\n══════════════════════════════════════\n");
    printf("  Total sum = %d", total_sum);
    printf("  (sum of 1..%d = %d × %d / 2 = %d ✓)\n", ARRAY_SIZE, ARRAY_SIZE, ARRAY_SIZE + 1, ARRAY_SIZE * (ARRAY_SIZE + 1) / 2);
    printf("══════════════════════════════════════\n");
    return EXIT_SUCCESS;
}

Editing — changes are local only

Expected Outputclick Run to execute live

========================================
  Parallel Partial Sum
========================================

Initializing array with values: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20

Creating 4 threads to compute partial sums...

Thread 0: processing elements from index 0 to 4 (values: 1, 2, 3, 4, 5)
Thread 0: computed partial sum = 15
Thread 1: processing elements from index 5 to 9 (values: 6, 7, 8, 9, 10)
Thread 1: computed partial sum = 40
Thread 2: processing elements from index 10 to 14 (values: 11, 12, 13, 14, 15)
Thread 2: computed partial sum = 65
Main thread: collected partial sum from thread 0 = 15
Main thread: collected partial sum from thread 1 = 40
Main thread: collected partial sum from thread 2 = 65
Thread 3: processing elements from index 15 to 19 (values: 16, 17, 18, 19, 20)
Thread 3: computed partial sum = 90
Main thread: collected partial sum from thread 3 = 90

Total sum of the array = 210

Main Exits Before Threads

What happens when main() returns while threads are still running — demonstrating the need for join or pthread_exit in main.

08-pthread-exit.c57 lines

/*
 * 08-pthread-exit.c — Main thread exits early, worker threads continue
 *
 * Key concepts: pthread_exit from main, process stays alive for threads
 * Compile: gcc -o early_exit 08-pthread-exit.c -lpthread
 * Run:     ./prog
 */
// File: main_exits_but_threads_continue.c
// Compile with: gcc -Wall -pthread main_exits_but_threads_continue.c -o main_exits_but_threads_continue

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>

// Thread function: prints its ID and iteration count.
void* thread_func(void *arg) {
    int id = *((int *) arg);
    for (int i = 0; i < 10; i++) {
        printf("[Thread %d] Iteration %d/10 — still running after main exited!\n", id, i + 1);
        sleep(1);
    }
    printf("[Thread %d] Finished all 10 iterations.\n", id);
    pthread_exit(NULL);
}

int main() {
    printf("\n");
    printf("========================================\n");
    printf("  Main Exits, Threads Continue\n");
    printf("========================================\n\n");
    pthread_t threads[3];
    int thread_ids[3] = {1, 2, 3};
    
    printf("[Main] Key concept: if main calls return/exit, ALL threads die.\n");
    printf("[Main] But if main calls pthread_exit, the process stays alive for worker threads!\n\n");

    for (int i = 0; i < 3; i++) {
        if (pthread_create(&threads[i], NULL, thread_func, (void *) &thread_ids[i]) != 0) {
            perror("[Main] ERROR: pthread_create failed");
            exit(EXIT_FAILURE);
        }
        printf("[Main] Created thread %d\n", thread_ids[i]);
    }

    printf("\n[Main] Calling pthread_exit() NOW — main thread stops, but threads keep running!\n");
    printf("[Main] Watch: the thread output continues even though main is gone.\n\n");
    
    // Instead of exiting normally (which would end the process and kill all threads),
    // the main thread calls pthread_exit. This causes the main thread to finish its work
    // while keeping the process alive until all non-detached threads complete.
    pthread_exit(NULL);
    
    // Note: Any code after pthread_exit() will not be executed.
    return EXIT_SUCCESS;
}

/*
 * 08-pthread-exit.c — Main thread exits early, worker threads continue
 *
 * Key concepts: pthread_exit from main, process stays alive for threads
 * Compile: gcc -o early_exit 08-pthread-exit.c -lpthread
 * Run:     ./prog
 */
// File: main_exits_but_threads_continue.c
// Compile with: gcc -Wall -pthread main_exits_but_threads_continue.c -o main_exits_but_threads_continue

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>

// Thread function: prints its ID and iteration count.
void* thread_func(void *arg) {
    int id = *((int *) arg);
    for (int i = 0; i < 10; i++) {
        printf("[Thread %d] Iteration %d/10 — still running after main exited!\n", id, i + 1);
        sleep(1);
    }
    printf("[Thread %d] Finished all 10 iterations.\n", id);
    pthread_exit(NULL);
}

int main() {
    printf("\n");
    printf("========================================\n");
    printf("  Main Exits, Threads Continue\n");
    printf("========================================\n\n");
    pthread_t threads[3];
    int thread_ids[3] = {1, 2, 3};
    
    printf("[Main] Key concept: if main calls return/exit, ALL threads die.\n");
    printf("[Main] But if main calls pthread_exit, the process stays alive for worker threads!\n\n");

for (int i = 0; i < 3; i++) {
        if (pthread_create(&threads[i], NULL, thread_func, (void *) &thread_ids[i]) != 0) {
            perror("[Main] ERROR: pthread_create failed");
            exit(EXIT_FAILURE);
        }
        printf("[Main] Created thread %d\n", thread_ids[i]);
    }

printf("\n[Main] Calling pthread_exit() NOW — main thread stops, but threads keep running!\n");
    printf("[Main] Watch: the thread output continues even though main is gone.\n\n");
    
    // Instead of exiting normally (which would end the process and kill all threads),
    // the main thread calls pthread_exit. This causes the main thread to finish its work
    // while keeping the process alive until all non-detached threads complete.
    pthread_exit(NULL);
    
    // Note: Any code after pthread_exit() will not be executed.
    return EXIT_SUCCESS;
}

Editing — changes are local only

Expected Outputclick Run to execute live

[Program timed out after 5 seconds]

Countdown Race Condition

Multiple threads decrementing a shared counter without synchronization — observe the race condition in action.

09-countdown-race.c98 lines

/*
 * 09-countdown-race.c — Thread race: first to count down to zero wins
 *
 * Demonstrates: Race conditions, cleanup handlers, pthread_exit() from main
 * Key concepts: volatile for shared state, pthread_cleanup_push/pop, main exits early
 * Compile: gcc -Wall -o race 09-countdown-race.c -lpthread
 * Run:     ./race
 *
 * Note: The winner check (if winner == -1) is a race condition itself!
 *       Two threads could both see winner==-1 and both declare victory.
 *       A mutex would fix this — see lesson 13.
 */

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>   // for pthread_create/exit/cleanup_push/pop
#include <unistd.h>    // for sleep()
#include <time.h>

// Structure to pass to each thread containing its ID and starting count.
typedef struct {
    int id;
    int count;
} thread_arg_t;

// Global variable to indicate the winner (-1 if none yet).
volatile int winner = -1;

// Cleanup handler: Prints a cleanup message if the thread is canceled.
void cleanup(void *arg) {
    int id = *((int *) arg);
    printf("[Thread %d] Cleanup handler called — releasing resources.\n", id);
}

// Thread function: each thread counts down and declares victory when it reaches zero.
void* countdown_race(void *arg) {
    thread_arg_t *data = (thread_arg_t *) arg;
    int id = data->id;
    int count = data->count;

    // Register a cleanup handler (for demonstration purposes)
    pthread_cleanup_push(cleanup, (void *) &data->id);

    while (count > 0) {
        sleep(1);  // Simulate work by waiting 1 second
        count--;
        printf("[Thread %d] Counting down: %d remaining\n", id, count);

        // If another thread already won, exit immediately.
        if (winner != -1 && winner != id) {
            printf("[Thread %d] Thread %d already won — I'm exiting.\n", id, winner);
            pthread_exit(NULL);
        }
    }

    // If count reached zero and no winner is declared yet, this thread wins.
    if (winner == -1) {
        winner = id;
        printf("[Thread %d] *** I WON THE RACE! *** (race condition: no mutex!)\n", id);
    }

    pthread_cleanup_pop(0);
    pthread_exit(NULL);
}

int main() {
    printf("\n");
    printf("========================================\n");
    printf("  Countdown Race Condition\n");
    printf("========================================\n\n");
    const int num_threads = 3;
    pthread_t threads[num_threads];
    thread_arg_t args[num_threads];
    int i, status;

    srand(time(NULL));  // Seed the random number generator

    printf("[Main] Each thread gets a random countdown (5-10 seconds). First to 0 wins!\n");
    printf("[Main] WARNING: the winner check has NO mutex — a race condition on purpose.\n\n");

    for (i = 0; i < num_threads; i++) {
        args[i].id = i;
        args[i].count = 5 + rand() % 6;
        status = pthread_create(&threads[i], NULL, countdown_race, (void *) &args[i]);
        if (status != 0) {
            fprintf(stderr, "[Main] ERROR: pthread_create failed for thread %d\n", i);
            exit(EXIT_FAILURE);
        }
        printf("[Main] Thread %d starts with countdown = %d\n", i, args[i].count);
    }

    printf("\n[Main] Race started! Main thread calling pthread_exit (threads keep running).\n\n");
    pthread_exit(NULL);  

    // Any code after pthread_exit() will not be executed.
    return EXIT_SUCCESS;
}

/*
 * 09-countdown-race.c — Thread race: first to count down to zero wins
 *
 * Demonstrates: Race conditions, cleanup handlers, pthread_exit() from main
 * Key concepts: volatile for shared state, pthread_cleanup_push/pop, main exits early
 * Compile: gcc -Wall -o race 09-countdown-race.c -lpthread
 * Run:     ./race
 *
 * Note: The winner check (if winner == -1) is a race condition itself!
 *       Two threads could both see winner==-1 and both declare victory.
 *       A mutex would fix this — see lesson 13.
 */

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>   // for pthread_create/exit/cleanup_push/pop
#include <unistd.h>    // for sleep()
#include <time.h>

// Structure to pass to each thread containing its ID and starting count.
typedef struct {
    int id;
    int count;
} thread_arg_t;

// Global variable to indicate the winner (-1 if none yet).
volatile int winner = -1;

// Cleanup handler: Prints a cleanup message if the thread is canceled.
void cleanup(void *arg) {
    int id = *((int *) arg);
    printf("[Thread %d] Cleanup handler called — releasing resources.\n", id);
}

// Thread function: each thread counts down and declares victory when it reaches zero.
void* countdown_race(void *arg) {
    thread_arg_t *data = (thread_arg_t *) arg;
    int id = data->id;
    int count = data->count;

// Register a cleanup handler (for demonstration purposes)
    pthread_cleanup_push(cleanup, (void *) &data->id);

while (count > 0) {
        sleep(1);  // Simulate work by waiting 1 second
        count--;
        printf("[Thread %d] Counting down: %d remaining\n", id, count);

// If another thread already won, exit immediately.
        if (winner != -1 && winner != id) {
            printf("[Thread %d] Thread %d already won — I'm exiting.\n", id, winner);
            pthread_exit(NULL);
        }
    }

// If count reached zero and no winner is declared yet, this thread wins.
    if (winner == -1) {
        winner = id;
        printf("[Thread %d] *** I WON THE RACE! *** (race condition: no mutex!)\n", id);
    }

pthread_cleanup_pop(0);
    pthread_exit(NULL);
}

int main() {
    printf("\n");
    printf("========================================\n");
    printf("  Countdown Race Condition\n");
    printf("========================================\n\n");
    const int num_threads = 3;
    pthread_t threads[num_threads];
    thread_arg_t args[num_threads];
    int i, status;

srand(time(NULL));  // Seed the random number generator

printf("[Main] Each thread gets a random countdown (5-10 seconds). First to 0 wins!\n");
    printf("[Main] WARNING: the winner check has NO mutex — a race condition on purpose.\n\n");

for (i = 0; i < num_threads; i++) {
        args[i].id = i;
        args[i].count = 5 + rand() % 6;
        status = pthread_create(&threads[i], NULL, countdown_race, (void *) &args[i]);
        if (status != 0) {
            fprintf(stderr, "[Main] ERROR: pthread_create failed for thread %d\n", i);
            exit(EXIT_FAILURE);
        }
        printf("[Main] Thread %d starts with countdown = %d\n", i, args[i].count);
    }

printf("\n[Main] Race started! Main thread calling pthread_exit (threads keep running).\n\n");
    pthread_exit(NULL);

// Any code after pthread_exit() will not be executed.
    return EXIT_SUCCESS;
}

Editing — changes are local only

Expected Outputclick Run to execute live

[Program timed out after 5 seconds]

Async Chat Simulator

A threaded chat simulator where one thread reads input and another displays messages asynchronously.

10-async-chat.c81 lines

/*
 * 10-async-chat.c — Async chat simulator with threads
 *
 * Key concepts: One thread reads, one writes, concurrent I/O
 * Compile: gcc -o chat 10-async-chat.c -lpthread
 * Run:     ./prog
 */
// File: chat_simulator.c
// Compile with: gcc -Wall -pthread chat_simulator.c -o chat_simulator

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
#include <time.h>

#define NUM_PARTICIPANTS 3
#define NUM_MESSAGES 5
#define LOG_SIZE 50

// Global shared log array (for messages)
char log_buffer[LOG_SIZE];
// Global variable indicating next log position
volatile int log_index = 0;

// Thread function: Each "chat participant" posts messages asynchronously.
void* chat_participant(void *arg) {
    int id = *((int *) arg);
    char message[50];

    for (int i = 0; i < NUM_MESSAGES; i++) {
        // Simulate message creation delay.
        sleep(1 + rand() % 2);
        
        // Create a simple message.
        snprintf(message, sizeof(message), "P%d msg %d", id, i);
        
        // Busy waiting: Wait until there is space in the log.
        while (log_index >= LOG_SIZE)
            ; // In a proper system, you would use condition variables
        
        // Post the message in the global log (no mutex used)
        int pos = log_index;
        log_buffer[pos] = '\0'; // Clear previous (not strictly necessary)
        strncpy(log_buffer, message, sizeof(log_buffer)-1);
        log_index++;
        printf("[Participant %d] Posted message %d/%d: \"%s\" (log position: %d)\n", id, i + 1, NUM_MESSAGES, message, pos);
    }
    
    pthread_exit(NULL);
}

int main() {
    printf("\n");
    printf("========================================\n");
    printf("  Async Chat Simulator\n");
    printf("========================================\n\n");
    pthread_t participants[NUM_PARTICIPANTS];
    int ids[NUM_PARTICIPANTS];
    int status, i;

    srand(time(NULL));

    printf("[Main] Starting %d chat participants, each will post %d messages.\n", NUM_PARTICIPANTS, NUM_MESSAGES);
    printf("[Main] WARNING: no mutex on shared log — messages may get lost or corrupted!\n\n");

    for (i = 0; i < NUM_PARTICIPANTS; i++) {
        ids[i] = i;
        status = pthread_create(&participants[i], NULL, chat_participant, (void *)&ids[i]);
        if (status != 0) {
            fprintf(stderr, "[Main] ERROR: pthread_create failed for participant %d\n", i);
            exit(EXIT_FAILURE);
        }
    }

    printf("[Main] All participants started. Main exits, chat continues...\n\n");
    pthread_exit(NULL);
    
    return EXIT_SUCCESS;
}

/*
 * 10-async-chat.c — Async chat simulator with threads
 *
 * Key concepts: One thread reads, one writes, concurrent I/O
 * Compile: gcc -o chat 10-async-chat.c -lpthread
 * Run:     ./prog
 */
// File: chat_simulator.c
// Compile with: gcc -Wall -pthread chat_simulator.c -o chat_simulator

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
#include <time.h>

#define NUM_PARTICIPANTS 3
#define NUM_MESSAGES 5
#define LOG_SIZE 50

// Global shared log array (for messages)
char log_buffer[LOG_SIZE];
// Global variable indicating next log position
volatile int log_index = 0;

// Thread function: Each "chat participant" posts messages asynchronously.
void* chat_participant(void *arg) {
    int id = *((int *) arg);
    char message[50];

for (int i = 0; i < NUM_MESSAGES; i++) {
        // Simulate message creation delay.
        sleep(1 + rand() % 2);
        
        // Create a simple message.
        snprintf(message, sizeof(message), "P%d msg %d", id, i);
        
        // Busy waiting: Wait until there is space in the log.
        while (log_index >= LOG_SIZE)
            ; // In a proper system, you would use condition variables
        
        // Post the message in the global log (no mutex used)
        int pos = log_index;
        log_buffer[pos] = '\0'; // Clear previous (not strictly necessary)
        strncpy(log_buffer, message, sizeof(log_buffer)-1);
        log_index++;
        printf("[Participant %d] Posted message %d/%d: \"%s\" (log position: %d)\n", id, i + 1, NUM_MESSAGES, message, pos);
    }
    
    pthread_exit(NULL);
}

int main() {
    printf("\n");
    printf("========================================\n");
    printf("  Async Chat Simulator\n");
    printf("========================================\n\n");
    pthread_t participants[NUM_PARTICIPANTS];
    int ids[NUM_PARTICIPANTS];
    int status, i;

srand(time(NULL));

printf("[Main] Starting %d chat participants, each will post %d messages.\n", NUM_PARTICIPANTS, NUM_MESSAGES);
    printf("[Main] WARNING: no mutex on shared log — messages may get lost or corrupted!\n\n");

for (i = 0; i < NUM_PARTICIPANTS; i++) {
        ids[i] = i;
        status = pthread_create(&participants[i], NULL, chat_participant, (void *)&ids[i]);
        if (status != 0) {
            fprintf(stderr, "[Main] ERROR: pthread_create failed for participant %d\n", i);
            exit(EXIT_FAILURE);
        }
    }

printf("[Main] All participants started. Main exits, chat continues...\n\n");
    pthread_exit(NULL);
    
    return EXIT_SUCCESS;
}

Editing — changes are local only

Expected Outputclick Run to execute live

[Program timed out after 5 seconds]

Threads + FIFO

Combining pthreads with named pipes (FIFO) — one thread reads from a FIFO while the main thread handles other work.

11-pthreads-fifo.c132 lines

/*
 * 11-pthreads-fifo.c — Threads combined with FIFO (named pipe)
 *
 * Key concepts: pthreads + mkfifo, IPC between threads and processes
 * Compile: gcc -o fifo_thread 11-pthreads-fifo.c -lpthread
 * Run:     ./prog
 */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <string.h>

// FIFO names
#define WRITER_TO_READER_FIFO "writer_to_reader_fifo"
#define READER_TO_WRITER_FIFO "reader_to_writer_fifo"

// Buffer size
#define BUFSIZE 256

// Number of messages
#define NUM_MESSAGES 10

void* writer_thread(void* arg);
void* reader_thread(void* arg);

int main() {
    pthread_t writer, reader;

    printf("\n");
    printf("══════════════════════════════════════\n");
    printf("  Threads + FIFO Communication\n");
    printf("══════════════════════════════════════\n\n");
    printf("[Main] Two threads communicate via named pipes (FIFOs).\n");
    printf("[Main] Writer sends %d messages, Reader acknowledges each.\n\n", NUM_MESSAGES);

    if (mkfifo(WRITER_TO_READER_FIFO, 0666) == -1) perror("[Main] mkfifo writer_to_reader");
    if (mkfifo(READER_TO_WRITER_FIFO, 0666) == -1) perror("[Main] mkfifo reader_to_writer");

    if (pthread_create(&writer, NULL, writer_thread, NULL) != 0) {
        perror("Failed to create writer thread");
        exit(EXIT_FAILURE);
    }
    if (pthread_create(&reader, NULL, reader_thread, NULL) != 0) {
        perror("Failed to create reader thread");
        exit(EXIT_FAILURE);
    }

    // Wait for threads to finish
    pthread_join(writer, NULL);
    pthread_join(reader, NULL);

    // Remove FIFOs after use
    unlink(WRITER_TO_READER_FIFO);
    unlink(READER_TO_WRITER_FIFO);

    return 0;
}

void* writer_thread(void* arg) {
    int write_fd = open(WRITER_TO_READER_FIFO, O_WRONLY);
    int read_fd = open(READER_TO_WRITER_FIFO, O_RDONLY);
    char message[BUFSIZE], response[BUFSIZE];

    if (write_fd == -1 || read_fd == -1) {
        perror("writer_thread: Failed to open FIFOs");
        pthread_exit(NULL);
    }

    for (int i = 0; i < NUM_MESSAGES; i++) {
        snprintf(message, BUFSIZE, "Message %d from writer", i);
        if (write(write_fd, message, strlen(message) + 1) == -1) {
            perror("writer_thread: Failed to write message");
            close(write_fd);
            close(read_fd);
            pthread_exit(NULL);
        }
        printf("[Writer] Sent \"%s\"\n", message);

        // Wait for acknowledgment from the reader
        if (read(read_fd, response, BUFSIZE) == -1) {
            perror("writer_thread: Failed to read response");
            close(write_fd);
            close(read_fd);
            pthread_exit(NULL);
        }
        printf("[Writer] Got ACK: \"%s\"\n", response);
    }

    close(write_fd);
    close(read_fd);
    pthread_exit(NULL);
}

void* reader_thread(void* arg) {
    int read_fd = open(WRITER_TO_READER_FIFO, O_RDONLY);
    int write_fd = open(READER_TO_WRITER_FIFO, O_WRONLY);
    char message[BUFSIZE], response[BUFSIZE];

    if (read_fd == -1 || write_fd == -1) {
        perror("reader_thread: Failed to open FIFOs");
        pthread_exit(NULL);
    }

    for (int i = 0; i < NUM_MESSAGES; i++) {
        // Wait for a message from the writer
        if (read(read_fd, message, BUFSIZE) == -1) {
            perror("reader_thread: Failed to read message");
            close(read_fd);
            close(write_fd);
            pthread_exit(NULL);
        }
        printf("[Reader] Got: \"%s\"\n", message);

        // Send acknowledgment to the writer
        snprintf(response, BUFSIZE, "Acknowledged: %s", message);
        if (write(write_fd, response, strlen(response) + 1) == -1) {
            perror("reader_thread: Failed to write acknowledgment");
            close(read_fd);
            close(write_fd);
            pthread_exit(NULL);
        }
        printf("[Reader] Sent ACK: \"%s\"\n", response);
    }

    close(read_fd);
    close(write_fd);
    pthread_exit(NULL);
}

/*
 * 11-pthreads-fifo.c — Threads combined with FIFO (named pipe)
 *
 * Key concepts: pthreads + mkfifo, IPC between threads and processes
 * Compile: gcc -o fifo_thread 11-pthreads-fifo.c -lpthread
 * Run:     ./prog
 */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <string.h>

// FIFO names
#define WRITER_TO_READER_FIFO "writer_to_reader_fifo"
#define READER_TO_WRITER_FIFO "reader_to_writer_fifo"

// Buffer size
#define BUFSIZE 256

// Number of messages
#define NUM_MESSAGES 10

void* writer_thread(void* arg);
void* reader_thread(void* arg);

int main() {
    pthread_t writer, reader;

printf("\n");
    printf("══════════════════════════════════════\n");
    printf("  Threads + FIFO Communication\n");
    printf("══════════════════════════════════════\n\n");
    printf("[Main] Two threads communicate via named pipes (FIFOs).\n");
    printf("[Main] Writer sends %d messages, Reader acknowledges each.\n\n", NUM_MESSAGES);

if (mkfifo(WRITER_TO_READER_FIFO, 0666) == -1) perror("[Main] mkfifo writer_to_reader");
    if (mkfifo(READER_TO_WRITER_FIFO, 0666) == -1) perror("[Main] mkfifo reader_to_writer");

if (pthread_create(&writer, NULL, writer_thread, NULL) != 0) {
        perror("Failed to create writer thread");
        exit(EXIT_FAILURE);
    }
    if (pthread_create(&reader, NULL, reader_thread, NULL) != 0) {
        perror("Failed to create reader thread");
        exit(EXIT_FAILURE);
    }

// Wait for threads to finish
    pthread_join(writer, NULL);
    pthread_join(reader, NULL);

// Remove FIFOs after use
    unlink(WRITER_TO_READER_FIFO);
    unlink(READER_TO_WRITER_FIFO);

return 0;
}

void* writer_thread(void* arg) {
    int write_fd = open(WRITER_TO_READER_FIFO, O_WRONLY);
    int read_fd = open(READER_TO_WRITER_FIFO, O_RDONLY);
    char message[BUFSIZE], response[BUFSIZE];

if (write_fd == -1 || read_fd == -1) {
        perror("writer_thread: Failed to open FIFOs");
        pthread_exit(NULL);
    }

for (int i = 0; i < NUM_MESSAGES; i++) {
        snprintf(message, BUFSIZE, "Message %d from writer", i);
        if (write(write_fd, message, strlen(message) + 1) == -1) {
            perror("writer_thread: Failed to write message");
            close(write_fd);
            close(read_fd);
            pthread_exit(NULL);
        }
        printf("[Writer] Sent \"%s\"\n", message);

// Wait for acknowledgment from the reader
        if (read(read_fd, response, BUFSIZE) == -1) {
            perror("writer_thread: Failed to read response");
            close(write_fd);
            close(read_fd);
            pthread_exit(NULL);
        }
        printf("[Writer] Got ACK: \"%s\"\n", response);
    }

close(write_fd);
    close(read_fd);
    pthread_exit(NULL);
}

void* reader_thread(void* arg) {
    int read_fd = open(WRITER_TO_READER_FIFO, O_RDONLY);
    int write_fd = open(READER_TO_WRITER_FIFO, O_WRONLY);
    char message[BUFSIZE], response[BUFSIZE];

if (read_fd == -1 || write_fd == -1) {
        perror("reader_thread: Failed to open FIFOs");
        pthread_exit(NULL);
    }

for (int i = 0; i < NUM_MESSAGES; i++) {
        // Wait for a message from the writer
        if (read(read_fd, message, BUFSIZE) == -1) {
            perror("reader_thread: Failed to read message");
            close(read_fd);
            close(write_fd);
            pthread_exit(NULL);
        }
        printf("[Reader] Got: \"%s\"\n", message);

// Send acknowledgment to the writer
        snprintf(response, BUFSIZE, "Acknowledged: %s", message);
        if (write(write_fd, response, strlen(response) + 1) == -1) {
            perror("reader_thread: Failed to write acknowledgment");
            close(read_fd);
            close(write_fd);
            pthread_exit(NULL);
        }
        printf("[Reader] Sent ACK: \"%s\"\n", response);
    }

close(read_fd);
    close(write_fd);
    pthread_exit(NULL);
}

Editing — changes are local only

Expected Outputclick Run to execute live

========================================
  Threads + FIFO Communication
========================================

Writer: Sent "Message 0 from writer"
Reader: Received "Message 0 from writer"
Reader: Sent "Acknowledged: Message 0 from writer"
Writer: Received "Acknowledged: Message 0 from writer"

========================================
  Threads + FIFO Communication
========================================

Writer: Sent "Message 1 from writer"
Reader: Received "Message 1 from writer"
Reader: Sent "Acknowledged: Message 1 from writer"
Writer: Received "Acknowledged: Message 1 from writer"

========================================
  Threads + FIFO Communication
========================================

Writer: Sent "Message 2 from writer"
Reader: Received "Message 2 from writer"
Reader: Sent "Acknowledged: Message 2 from writer"
Writer: Received "Acknowledged: Message 2 from writer"

========================================
  Threads + FIFO Communication
========================================

Writer: Sent "Message 3 from writer"
Reader: Received "Message 3 from writer"
Reader: Sent "Acknowledged: Message 3 from writer"
Writer: Received "Acknowledged: Message 3 from writer"

========================================
  Threads + FIFO Communication
========================================

Writer: Sent "Message 4 from writer"
Reader: Received "Message 4 from writer"
Reader: Sent "Acknowledged: Message 4 from writer"
Writer: Received "Acknowledged: Message 4 from writer"

========================================
  Threads + FIFO Communication
========================================

Writer: Sent "Message 5 from writer"
Reader: Received "Message 5 from writer"
Reader: Sent "Acknowledged: Message 5 from writer"
Writer: Received "Acknowledged: Message 5 from writer"

========================================
  Threads + FIFO Communication
========================================

Writer: Sent "Message 6 from writer"
Reader: Received "Message 6 from writer"
Reader: Sent "Acknowledged: Message 6 from writer"
Writer: Received "Acknowledged: Message 6 from writer"

========================================
  Threads + FIFO Communication
========================================

Writer: Sent "Message 7 from writer"
Reader: Received "Message 7 from writer"
Reader: Sent "Acknowledged: Message 7 from writer"
Writer: Received "Acknowledged: Message 7 from writer"

========================================
  Threads + FIFO Communication
========================================

Writer: Sent "Message 8 from writer"
Reader: Received "Message 8 from writer"
Reader: Sent "Acknowledged: Message 8 from writer"
Writer: Received "Acknowledged: Message 8 from writer"

========================================
  Threads + FIFO Communication
========================================

Writer: Sent "Message 9 from writer"
Reader: Received "Message 9 from writer"
Reader: Sent "Acknowledged: Message 9 from writer"
Writer: Received "Acknowledged: Message 9 from writer"

Open Full Terminal

Get a Linux terminal with all 11 files from this lesson pre-loaded. Compile, run, and experiment freely.

11. TCP Sockets

13. Synchronization