Thread Synchronization

/* Compile: gcc -o race race.c -lpthread */
#include <stdio.h>
#include <pthread.h>

#define NUM_THREADS  2
#define ITERATIONS   1000000

long counter = 0;                        /* shared global — the danger zone */
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;  /* declared globally */

/* BROKEN version — no synchronization */
void *broken_worker(void *arg) {
    for (long i = 0; i < ITERATIONS; i++) {
        counter++;   /* NOT ATOMIC: load, add 1, store — interleave = lost updates */
    }
    return NULL;
}

/* FIXED version — mutex guards the critical section */
void *fixed_worker(void *arg) {
    for (long i = 0; i < ITERATIONS; i++) {
        pthread_mutex_lock(&lock);   /* acquire lock — blocks if another thread holds it */
        counter++;                   /* critical section: only one thread at a time */
        pthread_mutex_unlock(&lock); /* release lock — next waiting thread proceeds */
    }
    return NULL;
}

int main(void) {
    pthread_t threads[NUM_THREADS];

    /* --- BROKEN run --- */
    counter = 0;
    for (int t = 0; t < NUM_THREADS; t++)
        pthread_create(&threads[t], NULL, broken_worker, NULL);
    for (int t = 0; t < NUM_THREADS; t++)
        pthread_join(threads[t], NULL);
    printf("BROKEN:  expected %ld, got %ld (lost ~%ld updates)\n",
           (long)(NUM_THREADS * ITERATIONS), counter,
           (long)(NUM_THREADS * ITERATIONS) - counter);

    /* --- FIXED run --- */
    counter = 0;
    for (int t = 0; t < NUM_THREADS; t++)
        pthread_create(&threads[t], NULL, fixed_worker, NULL);
    for (int t = 0; t < NUM_THREADS; t++)
        pthread_join(threads[t], NULL);
    printf("FIXED:   expected %ld, got %ld\n",
           (long)(NUM_THREADS * ITERATIONS), counter);

    pthread_mutex_destroy(&lock);
    return 0;
}

/* Compile: gcc -o prodcon prodcon.c -lpthread */
#include <stdio.h>
#include <pthread.h>
#include <semaphore.h>

#define BUFFER_SIZE  8
#define NUM_ITEMS    20

int buffer[BUFFER_SIZE];  /* circular buffer */
int head = 0, tail = 0;   /* consumer reads at head; producer writes at tail */

/* Three semaphores controlling the bounded buffer */
sem_t empty_slots;  /* counts how many slots are free (init = BUFFER_SIZE) */
sem_t full_slots;   /* counts how many slots have data (init = 0) */
pthread_mutex_t buf_lock = PTHREAD_MUTEX_INITIALIZER;  /* protects head/tail */

void *producer(void *arg) {
    for (int i = 0; i < NUM_ITEMS; i++) {
        int item = i * 10;               /* "produce" an item */

        sem_wait(&empty_slots);          /* block if buffer full */
        pthread_mutex_lock(&buf_lock);
        buffer[tail] = item;             /* write item into buffer */
        tail = (tail + 1) % BUFFER_SIZE; /* advance circular tail */
        printf("Produced: %d\n", item);
        pthread_mutex_unlock(&buf_lock);
        sem_post(&full_slots);           /* signal: one more item available */
    }
    return NULL;
}

void *consumer(void *arg) {
    for (int i = 0; i < NUM_ITEMS; i++) {
        sem_wait(&full_slots);           /* block if buffer empty */
        pthread_mutex_lock(&buf_lock);
        int item = buffer[head];         /* read item from buffer */
        head = (head + 1) % BUFFER_SIZE; /* advance circular head */
        printf("  Consumed: %d\n", item);
        pthread_mutex_unlock(&buf_lock);
        sem_post(&empty_slots);          /* signal: one more slot free */
    }
    return NULL;
}

int main(void) {
    /* Initialize semaphores */
    sem_init(&empty_slots, 0, BUFFER_SIZE); /* buffer starts fully empty */
    sem_init(&full_slots,  0, 0);           /* no items yet */

    pthread_t prod, cons;
    pthread_create(&prod, NULL, producer, NULL);
    pthread_create(&cons, NULL, consumer, NULL);
    pthread_join(prod, NULL);
    pthread_join(cons, NULL);

    sem_destroy(&empty_slots);
    sem_destroy(&full_slots);
    pthread_mutex_destroy(&buf_lock);
    return 0;
}

/* Compile: gcc -o deadlock deadlock.c -lpthread */
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>

pthread_mutex_t lock_A = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t lock_B = PTHREAD_MUTEX_INITIALIZER;

/* DEADLOCK version: Thread 0 acquires A then B, Thread 1 acquires B then A */
void *thread0_deadlock(void *arg) {
    pthread_mutex_lock(&lock_A);
    sleep(1);  /* force interleave: Thread 1 acquires B before Thread 0 asks for B */
    pthread_mutex_lock(&lock_B);  /* BLOCKS: Thread 1 holds B and waits for A */
    printf("Thread 0: inside critical section\n");
    pthread_mutex_unlock(&lock_B);
    pthread_mutex_unlock(&lock_A);
    return NULL;
}

void *thread1_deadlock(void *arg) {
    pthread_mutex_lock(&lock_B);
    sleep(1);  /* Thread 0 now holds A and waits for B — DEADLOCK */
    pthread_mutex_lock(&lock_A);  /* BLOCKS: Thread 0 holds A and waits for B */
    printf("Thread 1: inside critical section\n");
    pthread_mutex_unlock(&lock_A);
    pthread_mutex_unlock(&lock_B);
    return NULL;
}

/* FIXED version: BOTH threads acquire locks in the SAME ORDER (A then B) */
void *thread_fixed(void *arg) {
    long id = (long)arg;
    /* Locking hierarchy: always A before B — no circular wait possible */
    pthread_mutex_lock(&lock_A);
    pthread_mutex_lock(&lock_B);
    printf("Thread %ld: inside critical section (fixed)\n", id);
    pthread_mutex_unlock(&lock_B);  /* order of unlocking doesn't matter */
    pthread_mutex_unlock(&lock_A);
    return NULL;
}

int main(void) {
    pthread_t t0, t1;

    printf("--- Running FIXED version (locking hierarchy: A then B) ---\n");
    pthread_create(&t0, NULL, thread_fixed, (void*)0L);
    pthread_create(&t1, NULL, thread_fixed, (void*)1L);
    pthread_join(t0, NULL);
    pthread_join(t1, NULL);
    printf("Done — no deadlock!\n");

    /* NOTE: Running the deadlock version would hang indefinitely */
    return 0;
}