← C

Threads & Synchronization (APUE)

Socket Programming

← Threads & Synchronization (APUE)

Select a question from the sidebar

15 questions in this topic

Question 1 / 15

How does pthread_create() work, and what is the thread function signature?

pthread_create() creates a new thread within the calling process.

Prototype:

#include <pthread.h>
int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
                   void *(*start_routine)(void *), void *arg);

Parameters:

thread -- output parameter: stores the new thread's ID
attr -- thread attributes (NULL for defaults: joinable, default stack size)
start_routine -- function the thread will execute. Signature: void *func(void *arg)
arg -- single argument passed to the start routine (use a struct for multiple values)

Return value: 0 on success, error number on failure (does NOT set errno).

Thread function signature: Must be void *(*)(void *) -- takes a void pointer, returns a void pointer. The return value is available to pthread_join().

Key points:

The new thread starts executing start_routine immediately (scheduling order is indeterminate)
All threads share the process address space (global variables, heap, file descriptors)
Each thread has its own stack, thread ID, errno, signal mask, and scheduling priority
Compile and link with -pthread flag

Pseudo Code

1. Define thread function: void *worker(void *arg) { ... return result; }
2. pthread_t tid;
3. pthread_create(&tid, NULL, worker, arg)
4. Thread runs worker(arg) concurrently
5. pthread_join(tid, &result) -- wait for thread, get return value
6. Compile: gcc -pthread program.c

Code

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

typedef struct {
    int id;
    const char *message;
} thread_arg_t;

void *worker(void *arg) {
    thread_arg_t *ta = (thread_arg_t *)arg;
    printf("Thread %d: %s\n", ta->id, ta->message);

    /* Allocate and return a result */
    int *result = malloc(sizeof(int));
    *result = ta->id * 10;
    return result;
}

int main(void) {
    pthread_t threads[3];
    thread_arg_t args[3] = {
        {1, "Hello"}, {2, "World"}, {3, "!"}
    };

    /* Create threads */
    for (int i = 0; i < 3; i++) {
        int ret = pthread_create(&threads[i], NULL, worker, &args[i]);
        if (ret != 0) {
            fprintf(stderr, "pthread_create: %s\n", strerror(ret));
            return 1;
        }
    }

    /* Join threads and get results */
    for (int i = 0; i < 3; i++) {
        void *retval;
        pthread_join(threads[i], &retval);
        printf("Thread %d returned: %d\n", i + 1, *(int *)retval);
        free(retval);
    }

    return 0;
}

Thread 1: Hello
Thread 2: World
Thread 3: !
Thread 1 returned: 10
Thread 2 returned: 20
Thread 3 returned: 30
(Thread print order may vary)

Key Points

•Thread function signature: void *func(void *arg)
•pthread_create returns 0 on success, error number on failure (not -1)
•All threads share global memory, heap, and file descriptors
•Each thread has its own stack, errno, and signal mask
•Compile with -pthread flag

Gotchas

•Passing a pointer to a local variable as arg can be a race if the variable changes before thread reads it
•pthreads functions return error codes directly (not via errno)
•Forgetting -pthread flag causes undefined behavior (may seem to work but fail at runtime)
•Thread function must return void* -- returning without a value is undefined if pthread_join expects one

pthread_create(&tid, NULL, func, arg) creates a thread running func(arg). Function signature: void *func(void *). Returns 0 on success. Compile with -pthread.

•Signature: void *func(void *arg)
•Returns error code, not -1

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

void *worker(void *arg) {
    printf("Thread: %s\n", (char *)arg);
    return NULL;
}

int main(void) {
    pthread_t t;
    pthread_create(&t, NULL, worker, "hello");
    pthread_join(t, NULL);
    return 0;
}

Thread: hello

Must compile with -pthread flag

Question 2 / 15

What is the difference between pthread_join() and pthread_detach()?

Threads can be in one of two states regarding resource cleanup:

Joinable (default):

Another thread must call pthread_join() to collect the thread's return value and release its resources
Like waitpid() for processes -- if not joined, resources leak (thread zombie)
pthread_join(tid, &retval) blocks until the target thread terminates

Detached:

Resources are automatically released when the thread terminates
No thread can join it (pthread_join fails with EINVAL)
Created by calling pthread_detach(tid) or by setting the PTHREAD_CREATE_DETACHED attribute

When to use each:

Join when you need the thread's return value or need to synchronize on its completion
Detach for fire-and-forget threads (e.g., handling a client connection, background cleanup)

Important: A joinable thread that is never joined leaks resources (stack, thread ID) even after it has finished. This is the thread equivalent of a zombie process.

Pseudo Code

Joinable (default):
  pthread_create(&tid, NULL, func, arg)
  /* thread runs... terminates... resources held */
  pthread_join(tid, &retval)  /* blocks, collects retval, frees resources */

Detached:
  pthread_create(&tid, NULL, func, arg)
  pthread_detach(tid)  /* resources freed automatically on termination */
  /* cannot pthread_join(tid) -- would fail */

Or create detached from start:
  pthread_attr_init(&attr)
  pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED)
  pthread_create(&tid, &attr, func, arg)
  pthread_attr_destroy(&attr)

Code

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

void *joinable_worker(void *arg) {
    (void)arg;
    printf("Joinable thread running\n");
    return (void *)42L;  /* return value available to joiner */
}

void *detached_worker(void *arg) {
    (void)arg;
    printf("Detached thread running (fire-and-forget)\n");
    /* Resources freed automatically when this returns */
    return NULL;
}

int main(void) {
    pthread_t t1, t2;

    /* Joinable thread */
    pthread_create(&t1, NULL, joinable_worker, NULL);
    void *retval;
    pthread_join(t1, &retval);  /* blocks until t1 finishes */
    printf("Joinable returned: %ld\n", (long)retval);

    /* Detached thread (method 1: detach after create) */
    pthread_create(&t2, NULL, detached_worker, NULL);
    pthread_detach(t2);
    /* Cannot join t2 */

    /* Detached thread (method 2: create detached) */
    pthread_t t3;
    pthread_attr_t attr;
    pthread_attr_init(&attr);
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
    pthread_create(&t3, &attr, detached_worker, NULL);
    pthread_attr_destroy(&attr);

    sleep(1);  /* let detached threads finish */
    return 0;
}

Joinable thread running
Joinable returned: 42
Detached thread running (fire-and-forget)
Detached thread running (fire-and-forget)
(Detached thread output order may vary)

Key Points

•Joinable: must call pthread_join to collect return value and free resources
•Detached: resources freed automatically, cannot be joined
•Default state is joinable -- unjoin'd threads leak resources
•pthread_detach can be called by the thread itself or another thread
•Detaching or joining a thread more than once is undefined behavior

Gotchas

•Joining a detached thread is undefined behavior
•Detaching an already-joined thread is undefined behavior
•A joinable thread that terminates without being joined leaks resources
•pthread_join blocks the caller -- use pthread_tryjoin_np (Linux) for non-blocking

Joinable (default): must pthread_join() to get return value and free resources. Detached: auto-cleanup on exit, cannot be joined. Unjoin'd joinable threads leak resources (thread zombies).

•Joinable = must join; Detached = auto-cleanup
•Unjoin'd threads leak resources

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

void *func(void *a) { return a; }

int main(void) {
    pthread_t t;
    pthread_create(&t, NULL, func, (void*)42L);
    void *r;
    pthread_join(t, &r);  /* joinable: get result */
    printf("%ld\n", (long)r);

    pthread_create(&t, NULL, func, NULL);
    pthread_detach(t);  /* detached: fire and forget */
    return 0;
}

Joining a detached thread is undefined behavior

Question 3 / 15

What resources do threads share vs have privately?

All threads in a process share the same address space but have some private resources.

Shared between threads:

Text segment (code)
Global and static variables
Heap (dynamic memory)
File descriptors
Signal dispositions (handlers)
Current working directory
User and group IDs
Process ID

Private to each thread:

Thread ID (pthread_t)
Stack (local variables, function call chain)
errno (thread-local on modern systems)
Signal mask (pthread_sigmask)
Thread-specific data (pthread_key_t)
Scheduling priority and policy
CPU affinity
Pending signals (thread-directed)

Implications:

Sharing the heap means one thread's malloc() is visible to all threads, but also means concurrent access needs synchronization
Sharing file descriptors means close() in one thread affects all threads
Local variables are safe because each thread has its own stack, but do not return pointers to stack variables to other threads

Pseudo Code

Thread A and B share:
  global_var, heap_ptr, fd 3, signal handlers, CWD, PID

Thread A private:
  stack (local vars), errno, signal mask, thread ID, TLS

Thread B private:
  stack (local vars), errno, signal mask, thread ID, TLS

Consequences:
  global_var access: NEEDS synchronization (mutex)
  local_var: SAFE (own stack)
  malloc'd ptr: shared, NEEDS synchronization
  errno: SAFE (thread-local)
  close(fd): affects ALL threads

Code

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

int global_counter = 0;  /* SHARED -- needs synchronization */
pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;

void *thread_func(void *arg) {
    int thread_id = *(int *)arg;

    /* Stack variable -- private to this thread */
    int local_var = thread_id * 100;

    /* errno is thread-local */
    errno = 0;  /* does not affect other threads */

    /* Global variable -- shared, needs lock */
    pthread_mutex_lock(&mtx);
    global_counter++;
    printf("Thread %d: global=%d, local=%d, errno=%d\n",
           thread_id, global_counter, local_var, errno);
    pthread_mutex_unlock(&mtx);

    /* Heap -- shared but allocated here */
    int *heap_val = malloc(sizeof(int));
    *heap_val = local_var;
    return heap_val;  /* caller must free */
}

int main(void) {
    pthread_t threads[3];
    int ids[] = {1, 2, 3};

    for (int i = 0; i < 3; i++)
        pthread_create(&threads[i], NULL, thread_func, &ids[i]);

    for (int i = 0; i < 3; i++) {
        void *retval;
        pthread_join(threads[i], &retval);
        printf("Thread %d returned heap value: %d\n", i + 1, *(int *)retval);
        free(retval);
    }

    printf("Final global_counter = %d\n", global_counter);
    return 0;
}

Thread 1: global=1, local=100, errno=0
Thread 2: global=2, local=200, errno=0
Thread 3: global=3, local=300, errno=0
Thread 1 returned heap value: 100
Thread 2 returned heap value: 200
Thread 3 returned heap value: 300
Final global_counter = 3
(Thread execution order may vary)

Key Points

•Shared: globals, heap, fds, signal handlers, PID, CWD
•Private: stack, errno, signal mask, thread ID, TLS
•Shared data access requires synchronization (mutexes)
•errno is thread-local in modern pthreads implementations
•close() in one thread closes the fd for ALL threads

Gotchas

•Never return a pointer to a local variable from a thread function
•close(fd) in one thread can crash another thread using the same fd
•Static local variables are shared (they are not on the stack)
•malloc is thread-safe but the memory it returns is shared and needs synchronization

Threads share: globals, heap, fds, signal handlers. Private: stack, errno, signal mask, thread ID. Shared data needs synchronization. errno is thread-local.

•Globals/heap shared; stack/errno private
•Shared access needs mutexes

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

int shared = 0;
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;

void *func(void *a) {
    int local = 42;  /* private (stack) */
    pthread_mutex_lock(&m);
    shared++;  /* shared -- needs lock */
    pthread_mutex_unlock(&m);
    (void)a; (void)local;
    return NULL;
}

int main(void) {
    pthread_t t;
    pthread_create(&t, NULL, func, NULL);
    pthread_join(t, NULL);
    return 0;
}

close(fd) in one thread affects all threads

Question 4 / 15

How do mutexes work (pthread_mutex_init/lock/unlock/destroy)?

A mutex (mutual exclusion) ensures that only one thread can execute a critical section at a time.

Key functions:

int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr);
int pthread_mutex_lock(pthread_mutex_t *mutex);     /* blocks if locked */
int pthread_mutex_trylock(pthread_mutex_t *mutex);  /* non-blocking */
int pthread_mutex_unlock(pthread_mutex_t *mutex);
int pthread_mutex_destroy(pthread_mutex_t *mutex);

Static initialization:

pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;  /* no init/destroy needed */

Mutex types (via attributes):

PTHREAD_MUTEX_DEFAULT (or NORMAL): undefined behavior on double-lock
PTHREAD_MUTEX_ERRORCHECK: returns EDEADLK on double-lock by same thread
PTHREAD_MUTEX_RECURSIVE: allows same thread to lock multiple times (must unlock same number)

Usage pattern:

pthread_mutex_lock(&mtx);
/* critical section: only one thread here at a time */
pthread_mutex_unlock(&mtx);

Important: Protect the DATA, not the code. Lock the mutex before accessing shared data and unlock after. Keep critical sections as short as possible to maximize concurrency.

Pseudo Code

1. Initialize: mutex = PTHREAD_MUTEX_INITIALIZER (or pthread_mutex_init)
2. Before accessing shared data: pthread_mutex_lock(&mutex)
3. Access/modify shared data (critical section)
4. After done: pthread_mutex_unlock(&mutex)
5. Cleanup: pthread_mutex_destroy(&mutex)

Rules:
- Lock and unlock must be in the same thread
- Do not lock a normal mutex twice (deadlock)
- Do not unlock a mutex you did not lock (undefined)

Code

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

#define NUM_THREADS 10
#define ITERATIONS 100000

static int counter = 0;
static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;

void *increment(void *arg) {
    (void)arg;
    for (int i = 0; i < ITERATIONS; i++) {
        pthread_mutex_lock(&mtx);
        counter++;  /* protected by mutex */
        pthread_mutex_unlock(&mtx);
    }
    return NULL;
}

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

    for (int i = 0; i < NUM_THREADS; i++)
        pthread_create(&threads[i], NULL, increment, NULL);

    for (int i = 0; i < NUM_THREADS; i++)
        pthread_join(threads[i], NULL);

    printf("Counter: %d (expected %d)\n",
           counter, NUM_THREADS * ITERATIONS);
    /* Without mutex: counter < expected (race condition) */
    /* With mutex: counter == expected (correct) */

    pthread_mutex_destroy(&mtx);
    return 0;
}

Counter: 1000000 (expected 1000000)

Key Points

•Mutex ensures mutual exclusion -- only one thread in the critical section
•PTHREAD_MUTEX_INITIALIZER for static initialization (no destroy needed)
•pthread_mutex_trylock returns EBUSY if already locked (non-blocking)
•Keep critical sections short for maximum concurrency
•ERRORCHECK type detects double-lock; RECURSIVE type allows it

Gotchas

•Locking a normal mutex twice from the same thread is undefined (usually deadlock)
•Unlocking a mutex not locked by the current thread is undefined behavior
•Destroying a locked mutex is undefined behavior
•Forgetting to unlock (e.g., on error path) causes deadlock -- consider cleanup handlers

Mutex ensures one thread at a time in critical section. pthread_mutex_lock() blocks if locked, unlock() releases. Use PTHREAD_MUTEX_INITIALIZER for static init. Keep critical sections short.

•lock/critical section/unlock pattern
•PTHREAD_MUTEX_INITIALIZER for static init

#include <pthread.h>

int shared = 0;
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;

void *func(void *a) {
    (void)a;
    pthread_mutex_lock(&m);
    shared++;
    pthread_mutex_unlock(&m);
    return NULL;
}

Double-lock from same thread = undefined (deadlock with NORMAL type)

Question 5 / 15

What causes deadlocks with mutexes, and how do you prevent them?

Deadlock with mutexes occurs when threads form a circular wait chain, each holding one mutex and waiting for another.

Common scenario:

Thread A: lock(mutex1) -> lock(mutex2)  // blocks waiting for B
Thread B: lock(mutex2) -> lock(mutex1)  // blocks waiting for A

Prevention strategies:

Lock ordering: Always acquire mutexes in the same global order. If all threads lock mutex1 before mutex2, no circular wait can form.
Try-lock with backoff: Use pthread_mutex_trylock(). If it fails (EBUSY), release all held mutexes and retry.
Single coarse lock: Use one mutex instead of multiple. Reduces concurrency but eliminates deadlock.
Lock hierarchy: Assign a numerical level to each mutex. Only lock higher-level mutexes while holding lower-level ones.
Timeout: Use pthread_mutex_timedlock() (POSIX) to detect potential deadlocks.

Detection tools: Valgrind (helgrind/drd), Thread Sanitizer (-fsanitize=thread), PTHREAD_MUTEX_ERRORCHECK type.

Best practice: Lock ordering is the most widely used and reliable strategy. Document the ordering in comments.

Pseudo Code

DEADLOCK:
  Thread A: lock(m1) -> lock(m2)  // waits for B
  Thread B: lock(m2) -> lock(m1)  // waits for A
  // Circular wait -> deadlock!

FIX (lock ordering):
  Thread A: lock(m1) -> lock(m2)  // always m1 first
  Thread B: lock(m1) -> lock(m2)  // same order!
  // Thread B blocks on m1, but A can proceed -> no deadlock

FIX (try-lock):
  Thread A: lock(m1); if trylock(m2)==EBUSY: unlock(m1); retry

Code

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

pthread_mutex_t m1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t m2 = PTHREAD_MUTEX_INITIALIZER;

/* CORRECT: lock ordering (always m1 before m2) */
void *safe_worker(void *arg) {
    (void)arg;
    pthread_mutex_lock(&m1);  /* always lock m1 first */
    pthread_mutex_lock(&m2);  /* then m2 */
    printf("Thread %lu: both locks held\n", (unsigned long)pthread_self());
    pthread_mutex_unlock(&m2);
    pthread_mutex_unlock(&m1);
    return NULL;
}

/* ALTERNATIVE: try-lock with backoff */
void *trylock_worker(void *arg) {
    (void)arg;
    int locked = 0;
    while (!locked) {
        pthread_mutex_lock(&m1);
        if (pthread_mutex_trylock(&m2) == 0) {
            locked = 1;  /* got both */
        } else {
            pthread_mutex_unlock(&m1);  /* release and retry */
            /* Optional: sched_yield() or short sleep */
        }
    }
    printf("Thread: both locks via trylock\n");
    pthread_mutex_unlock(&m2);
    pthread_mutex_unlock(&m1);
    return NULL;
}

int main(void) {
    pthread_t t1, t2;
    pthread_create(&t1, NULL, safe_worker, NULL);
    pthread_create(&t2, NULL, safe_worker, NULL);
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    printf("No deadlock with lock ordering\n");
    return 0;
}

Thread <id>: both locks held
Thread <id>: both locks held
No deadlock with lock ordering
(Thread IDs vary per run)

Key Points

•Deadlock: circular wait between threads holding different mutexes
•Lock ordering is the primary prevention strategy
•trylock + backoff avoids blocking but may cause livelock
•PTHREAD_MUTEX_ERRORCHECK detects double-lock (returns EDEADLK)
•Thread Sanitizer (-fsanitize=thread) detects potential deadlocks at runtime

Gotchas

•Lock ordering must be documented and enforced by all code paths
•trylock backoff can cause livelock (both threads keep retrying)
•Holding a mutex while calling unknown code (callbacks) risks deadlock
•Forgetting to unlock on error paths is a common cause of deadlock

Deadlock: Thread A holds m1, waits for m2; Thread B holds m2, waits for m1. Prevent with lock ordering (always lock in same order), trylock+backoff, or single coarse lock.

•Lock ordering prevents deadlocks
•Document the ordering

#include <pthread.h>

pthread_mutex_t m1, m2;

/* Always lock m1 before m2 */
void safe(void) {
    pthread_mutex_lock(&m1);
    pthread_mutex_lock(&m2);
    /* critical section */
    pthread_mutex_unlock(&m2);
    pthread_mutex_unlock(&m1);
}

Callbacks while holding locks risk deadlock

Question 6 / 15

How do condition variables work (pthread_cond_wait/signal/broadcast)?

Condition variables allow threads to wait for a specific condition to become true, without busy-waiting.

Key functions:

int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);
int pthread_cond_signal(pthread_cond_t *cond);     /* wake ONE waiter */
int pthread_cond_broadcast(pthread_cond_t *cond);  /* wake ALL waiters */
int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex,
                           const struct timespec *abstime);

How pthread_cond_wait works (atomically):

Unlocks the mutex
Puts the calling thread to sleep
When woken up, re-acquires the mutex before returning

Why always use a while loop (not if):

pthread_mutex_lock(&mtx);
while (!condition)  /* NOT if (!condition) */
    pthread_cond_wait(&cond, &mtx);
/* condition is true here, mutex is held */
pthread_mutex_unlock(&mtx);

Reasons for the while loop:

Spurious wakeups: pthread_cond_wait can return without being signaled
Stolen wakeups: Another thread might have changed the condition before this thread re-acquires the mutex
Broadcast: Multiple waiters wake up, but only one should proceed

signal vs broadcast:

signal wakes ONE waiting thread (use when exactly one waiter should proceed)
broadcast wakes ALL waiting threads (use when multiple waiters might proceed, or when condition meaning has changed for all)

Pseudo Code

Waiter:
  pthread_mutex_lock(&mutex)
  while (!condition)                    // always while, not if
      pthread_cond_wait(&cond, &mutex)  // atomic: unlock + sleep + relock
  // condition is true, mutex is held
  /* do work */
  pthread_mutex_unlock(&mutex)

Signaler:
  pthread_mutex_lock(&mutex)
  condition = true                      // modify condition
  pthread_cond_signal(&cond)            // wake one waiter
  pthread_mutex_unlock(&mutex)

Code

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

static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
static int data_ready = 0;
static int shared_data = 0;

void *producer(void *arg) {
    (void)arg;
    sleep(1);  /* simulate work */

    pthread_mutex_lock(&mtx);
    shared_data = 42;
    data_ready = 1;
    printf("Producer: data ready\n");
    pthread_cond_signal(&cond);  /* wake one consumer */
    pthread_mutex_unlock(&mtx);

    return NULL;
}

void *consumer(void *arg) {
    (void)arg;
    pthread_mutex_lock(&mtx);

    while (!data_ready)  /* MUST be while, not if */
        pthread_cond_wait(&cond, &mtx);  /* atomic unlock+sleep+relock */

    printf("Consumer: got data = %d\n", shared_data);
    pthread_mutex_unlock(&mtx);

    return NULL;
}

int main(void) {
    pthread_t prod, cons;
    pthread_create(&cons, NULL, consumer, NULL);
    pthread_create(&prod, NULL, producer, NULL);

    pthread_join(prod, NULL);
    pthread_join(cons, NULL);

    pthread_mutex_destroy(&mtx);
    pthread_cond_destroy(&cond);
    return 0;
}

Producer: data ready
Consumer: got data = 42

Key Points

•pthread_cond_wait atomically unlocks mutex + sleeps + relocks on wake
•ALWAYS check condition in a while loop (spurious wakeups)
•signal wakes one waiter; broadcast wakes all
•The mutex must be locked before calling cond_wait
•Condition variables have no memory -- signal with no waiter is lost

Gotchas

•Using if instead of while leads to bugs with spurious wakeups
•Signal with no waiting thread is a no-op (signal is not saved)
•The mutex must be the SAME mutex for all waiters on the same condvar
•Destroying a condvar while threads are waiting is undefined behavior

pthread_cond_wait(&cond, &mtx) atomically unlocks mutex, sleeps, and re-locks on wake. Always use in a while(!condition) loop (spurious wakeups). signal wakes one, broadcast wakes all.

•Always while(!condition), never if
•cond_wait atomically unlocks + sleeps + relocks

#include <pthread.h>

pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t c = PTHREAD_COND_INITIALIZER;
int ready = 0;

void *waiter(void *a) {
    (void)a;
    pthread_mutex_lock(&m);
    while (!ready) pthread_cond_wait(&c, &m);
    pthread_mutex_unlock(&m);
    return NULL;
}

void *signaler(void *a) {
    (void)a;
    pthread_mutex_lock(&m);
    ready = 1;
    pthread_cond_signal(&c);
    pthread_mutex_unlock(&m);
    return NULL;
}

Spurious wakeups make if-check incorrect

Question 7 / 15

How do you implement the producer-consumer pattern with mutexes and condition variables?

The producer-consumer pattern with a bounded buffer uses a mutex for mutual exclusion and two condition variables: one for "not full" (producer waits when buffer is full) and one for "not empty" (consumer waits when buffer is empty).

Components:

Circular buffer with in and out indices
count -- number of items currently in buffer
mutex -- protects buffer, count, and indices
not_full -- producer waits on this when buffer is full
not_empty -- consumer waits on this when buffer is empty

Producer:

lock(mutex)
while (count == BUFFER_SIZE)
    cond_wait(not_full, mutex)
buffer[in] = item; in = (in+1) % SIZE; count++
cond_signal(not_empty)
unlock(mutex)

Consumer:

lock(mutex)
while (count == 0)
    cond_wait(not_empty, mutex)
item = buffer[out]; out = (out+1) % SIZE; count--
cond_signal(not_full)
unlock(mutex)

Pseudo Code

Buffer: array[SIZE], in=0, out=0, count=0
Mutex: mutex
Condvars: not_full, not_empty

Produce:
  lock(mutex)
  while count == SIZE: wait(not_full, mutex)  // buffer full
  buffer[in] = item; in = (in+1)%SIZE; count++
  signal(not_empty)  // wake consumer
  unlock(mutex)

Consume:
  lock(mutex)
  while count == 0: wait(not_empty, mutex)   // buffer empty
  item = buffer[out]; out = (out+1)%SIZE; count--
  signal(not_full)  // wake producer
  unlock(mutex)

Code

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

#define BUF_SIZE 5
#define NUM_ITEMS 20

static int buffer[BUF_SIZE];
static int in = 0, out = 0, count = 0;
static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t not_full = PTHREAD_COND_INITIALIZER;
static pthread_cond_t not_empty = PTHREAD_COND_INITIALIZER;

void *producer(void *arg) {
    (void)arg;
    for (int i = 1; i <= NUM_ITEMS; i++) {
        pthread_mutex_lock(&mtx);
        while (count == BUF_SIZE)
            pthread_cond_wait(&not_full, &mtx);

        buffer[in] = i;
        in = (in + 1) % BUF_SIZE;
        count++;
        printf("Produced: %d (count=%d)\n", i, count);

        pthread_cond_signal(&not_empty);
        pthread_mutex_unlock(&mtx);
    }
    return NULL;
}

void *consumer(void *arg) {
    (void)arg;
    for (int i = 0; i < NUM_ITEMS; i++) {
        pthread_mutex_lock(&mtx);
        while (count == 0)
            pthread_cond_wait(&not_empty, &mtx);

        int item = buffer[out];
        out = (out + 1) % BUF_SIZE;
        count--;
        printf("Consumed: %d (count=%d)\n", item, count);

        pthread_cond_signal(&not_full);
        pthread_mutex_unlock(&mtx);
    }
    return NULL;
}

int main(void) {
    pthread_t prod, cons;
    pthread_create(&prod, NULL, producer, NULL);
    pthread_create(&cons, NULL, consumer, NULL);
    pthread_join(prod, NULL);
    pthread_join(cons, NULL);
    return 0;
}

Produced: 1 (count=1)
Produced: 2 (count=2)
...
Consumed: 1 (count=...)
...
Produced: 20 (count=...)
Consumed: 20 (count=0)
(Interleaving of Produced/Consumed varies;
 all 20 items produced and consumed exactly once)

Key Points

•Two condition variables: not_full (for producer) and not_empty (for consumer)
•One mutex protects the shared buffer, count, and indices
•Producer signals not_empty after adding; consumer signals not_full after removing
•while loops handle spurious wakeups and multiple producers/consumers
•Circular buffer with modular arithmetic avoids buffer shifting

Gotchas

•Using signal when multiple consumers exist may wake the wrong one -- consider broadcast
•Forgetting the while loop on cond_wait leads to buffer overrun/underrun
•With multiple producers AND multiple consumers, broadcast may be more correct
•The mutex must be held when signaling (or at least when modifying the condition)

Bounded buffer: mutex + two condvars (not_full, not_empty). Producer waits on not_full when full, signals not_empty after producing. Consumer waits on not_empty when empty, signals not_full after consuming.

•Two condvars: not_full and not_empty
•while loop for cond_wait

#include <pthread.h>

int buf[5], in=0, out=0, cnt=0;
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t nf = PTHREAD_COND_INITIALIZER;
pthread_cond_t ne = PTHREAD_COND_INITIALIZER;

void produce(int item) {
    pthread_mutex_lock(&m);
    while (cnt == 5) pthread_cond_wait(&nf, &m);
    buf[in] = item; in = (in+1)%5; cnt++;
    pthread_cond_signal(&ne);
    pthread_mutex_unlock(&m);
}

Use broadcast with multiple consumers

Question 8 / 15

How do reader-writer locks work (pthread_rwlock)?

Reader-writer locks allow multiple concurrent readers OR one exclusive writer, optimizing for read-heavy workloads.

Key functions:

int pthread_rwlock_init(pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr);
int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);  /* shared/read lock */
int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);  /* exclusive/write lock */
int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);

Semantics:

Multiple threads can hold read locks simultaneously
Only one thread can hold a write lock (exclusive)
A write lock blocks until all readers release
A read lock blocks if a writer is waiting (to prevent writer starvation on some implementations)

Static initialization:

pthread_rwlock_t rwl = PTHREAD_RWLOCK_INITIALIZER;

When to use:

Data is read much more often than written
Read operations are expensive enough that concurrent execution matters
With few readers or fast reads, a plain mutex may be faster (rwlock has more overhead)

Pseudo Code

Multiple readers (concurrent):
  pthread_rwlock_rdlock(&rwl)
  /* read shared data */
  pthread_rwlock_unlock(&rwl)

Single writer (exclusive):
  pthread_rwlock_wrlock(&rwl)
  /* modify shared data */
  pthread_rwlock_unlock(&rwl)

Concurrency:
  N readers in parallel: OK
  1 writer at a time: blocks all readers and other writers
  Writer waiting: may block new readers (fairness)

Code

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

static int shared_data = 0;
static pthread_rwlock_t rwl = PTHREAD_RWLOCK_INITIALIZER;

void *reader(void *arg) {
    int id = *(int *)arg;
    for (int i = 0; i < 5; i++) {
        pthread_rwlock_rdlock(&rwl);
        printf("Reader %d: data = %d\n", id, shared_data);
        pthread_rwlock_unlock(&rwl);
        usleep(100000);
    }
    return NULL;
}

void *writer(void *arg) {
    (void)arg;
    for (int i = 0; i < 3; i++) {
        pthread_rwlock_wrlock(&rwl);
        shared_data += 10;
        printf("Writer: data = %d\n", shared_data);
        pthread_rwlock_unlock(&rwl);
        usleep(200000);
    }
    return NULL;
}

int main(void) {
    pthread_t readers[3], wr;
    int ids[] = {1, 2, 3};

    for (int i = 0; i < 3; i++)
        pthread_create(&readers[i], NULL, reader, &ids[i]);
    pthread_create(&wr, NULL, writer, NULL);

    for (int i = 0; i < 3; i++)
        pthread_join(readers[i], NULL);
    pthread_join(wr, NULL);

    pthread_rwlock_destroy(&rwl);
    return 0;
}

Reader 1: data = 0
Reader 2: data = 0
Reader 3: data = 0
Writer: data = 10
Reader 1: data = 10
...
Writer: data = 30
(Reader/Writer interleaving varies;
 writer increments by 10 three times to 30)

Key Points

•Multiple concurrent readers OR one exclusive writer
•rdlock for reading, wrlock for writing, unlock for both
•Optimized for read-heavy workloads
•Writer starvation possible (implementation-dependent fairness)
•Higher overhead than mutex -- only use when reads greatly outnumber writes

Gotchas

•rwlock has more overhead than mutex -- do not use for trivial reads
•Writer starvation: continuous readers may starve writers (check implementation)
•Upgrading a read lock to write lock is not supported (must release and re-acquire)
•Recursive read locks are allowed; recursive write locks are undefined

Reader-writer lock: rdlock for shared read (many), wrlock for exclusive write (one). Better than mutex for read-heavy workloads. PTHREAD_RWLOCK_INITIALIZER for static init.

•Multiple readers OR one writer
•Better for read-heavy patterns

#include <pthread.h>

int data = 0;
pthread_rwlock_t rw = PTHREAD_RWLOCK_INITIALIZER;

void read_data(void) {
    pthread_rwlock_rdlock(&rw);
    /* read data (many threads here) */
    pthread_rwlock_unlock(&rw);
}

void write_data(int val) {
    pthread_rwlock_wrlock(&rw);
    data = val;  /* exclusive */
    pthread_rwlock_unlock(&rw);
}

Cannot upgrade rdlock to wrlock

Question 9 / 15

How does thread-specific data (TSD) work with pthread_key?

Thread-specific data (TSD) allows each thread to have its own copy of a global-like variable. All threads use the same key, but each gets a different value.

POSIX TSD API:

int pthread_key_create(pthread_key_t *key, void (*destructor)(void *));
int pthread_setspecific(pthread_key_t key, const void *value);
void *pthread_getspecific(pthread_key_t key);
int pthread_key_delete(pthread_key_t key);

How it works:

pthread_key_create() creates a key (called once, typically with pthread_once())
Each thread calls pthread_setspecific() to set its own value
pthread_getspecific() returns the calling thread's value
When a thread exits, the destructor is called with the thread's value (for cleanup)

C11 alternative -- _Thread_local / thread_local:

_Thread_local int per_thread_var = 0;  /* C11 */

Simpler but cannot have destructor functions and only works for static/global variables.

Use cases:

Per-thread error codes or contexts
Per-thread allocators or caches
Making non-thread-safe libraries thread-safe (e.g., per-thread buffers)

Pseudo Code

1. pthread_key_create(&key, destructor)  -- once
2. Each thread:
   a. ptr = malloc(sizeof(my_data))
   b. pthread_setspecific(key, ptr)  -- set this thread's value
   c. ptr = pthread_getspecific(key) -- get this thread's value
3. Thread exits -> destructor(ptr) called automatically

C11 alternative:
  _Thread_local int x;  // each thread gets its own x

Code

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

static pthread_key_t tsd_key;
static pthread_once_t key_once = PTHREAD_ONCE_INIT;

void destructor(void *ptr) {
    printf("Destructor: freeing thread data\n");
    free(ptr);
}

void init_key(void) {
    pthread_key_create(&tsd_key, destructor);
}

typedef struct {
    int thread_id;
    int call_count;
} thread_data_t;

thread_data_t *get_thread_data(void) {
    /* Initialize key once (thread-safe) */
    pthread_once(&key_once, init_key);

    thread_data_t *data = pthread_getspecific(tsd_key);
    if (data == NULL) {
        /* First call in this thread -- allocate */
        data = calloc(1, sizeof(thread_data_t));
        pthread_setspecific(tsd_key, data);
    }
    return data;
}

void *worker(void *arg) {
    int id = *(int *)arg;
    thread_data_t *data = get_thread_data();
    data->thread_id = id;

    for (int i = 0; i < 3; i++) {
        data->call_count++;
        printf("Thread %d: call_count = %d\n", id, data->call_count);
    }
    /* destructor called automatically on thread exit */
    return NULL;
}

int main(void) {
    pthread_t threads[3];
    int ids[] = {1, 2, 3};
    for (int i = 0; i < 3; i++)
        pthread_create(&threads[i], NULL, worker, &ids[i]);
    for (int i = 0; i < 3; i++)
        pthread_join(threads[i], NULL);
    pthread_key_delete(tsd_key);
    return 0;
}

Thread 1: call_count = 1
Thread 1: call_count = 2
Thread 1: call_count = 3
Thread 2: call_count = 1
Thread 2: call_count = 2
Thread 2: call_count = 3
Thread 3: call_count = 1
Thread 3: call_count = 2
Thread 3: call_count = 3
Destructor: freeing thread data
Destructor: freeing thread data
Destructor: freeing thread data
(Thread order may vary; each thread counts 1-3 independently)

Key Points

•Same key, different value per thread
•Destructor called automatically when thread exits
•Use pthread_once to ensure key is created exactly once
•C11 _Thread_local is simpler but lacks destructors
•Max PTHREAD_KEYS_MAX keys per process (typically 128+)

Gotchas

•Destructor is NOT called for the main thread (it calls exit, not pthread_exit)
•pthread_key_delete does not call destructors -- threads must exit first
•If destructor sets TSD to non-NULL, it may be called again (up to PTHREAD_DESTRUCTOR_ITERATIONS times)
•getspecific returns NULL before setspecific is called -- must check

Thread-specific data: one key, each thread gets its own value. pthread_key_create() once, setspecific/getspecific per thread. Destructor called on thread exit. C11 _Thread_local is simpler.

•Same key, different value per thread
•Destructor auto-cleans on thread exit

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

pthread_key_t key;

void cleanup(void *p) { free(p); }

void init(void) { pthread_key_create(&key, cleanup); }

void *func(void *a) {
    int *p = malloc(sizeof(int));
    *p = *(int*)a;
    pthread_setspecific(key, p);  /* my own copy */
    int *mine = pthread_getspecific(key);
    (void)mine;
    return NULL; /* destructor frees p */
}

Destructor not called for main thread

Question 10 / 15

How does thread cancellation work (pthread_cancel and cleanup handlers)?

Thread cancellation allows one thread to request that another thread terminate.

Key functions:

int pthread_cancel(pthread_t thread);
int pthread_setcancelstate(int state, int *oldstate);  /* ENABLE/DISABLE */
int pthread_setcanceltype(int type, int *oldtype);     /* DEFERRED/ASYNCHRONOUS */
void pthread_testcancel(void);  /* explicit cancellation point */

void pthread_cleanup_push(void (*routine)(void *), void *arg);
void pthread_cleanup_pop(int execute);

Cancellation states:

PTHREAD_CANCEL_ENABLE (default): cancellation requests are honored
PTHREAD_CANCEL_DISABLE: requests are held pending

Cancellation types:

PTHREAD_CANCEL_DEFERRED (default): cancellation only at cancellation points (read, write, sleep, pthread_cond_wait, etc.)
PTHREAD_CANCEL_ASYNCHRONOUS: cancellation can happen at any time (dangerous!)

Cleanup handlers (push/pop) ensure resources are released even if the thread is cancelled:

pthread_cleanup_push() registers a cleanup function
pthread_cleanup_pop() removes it (executes if argument is non-zero)
Handlers are called in LIFO order when the thread is cancelled or calls pthread_exit()

Important: push/pop must be matched and in the same lexical scope (they may be implemented as macros with { and }).

Pseudo Code

Thread A: pthread_cancel(thread_B)  -- request cancellation

Thread B (deferred cancellation):
  pthread_cleanup_push(cleanup_func, resource)
  /* ... work ... */
  read()   // <-- cancellation point: thread B terminated here
  pthread_cleanup_pop(1)  // cleanup_func called if cancelled

Cleanup handlers called in LIFO order:
  push(handler1)  push(handler2)  push(handler3)
  cancel -> handler3, handler2, handler1 called

Code

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

void cleanup_handler(void *arg) {
    char *resource = (char *)arg;
    printf("Cleanup: freeing %s\n", resource);
    free(resource);
}

void *worker(void *arg) {
    (void)arg;
    char *buf = malloc(1024);
    snprintf(buf, 1024, "allocated buffer");

    /* Register cleanup handler */
    pthread_cleanup_push(cleanup_handler, buf);

    printf("Worker: starting long operation...\n");
    for (int i = 0; ; i++) {
        /* sleep is a cancellation point */
        sleep(1);
        printf("Worker: iteration %d\n", i);
    }

    /* This would be called if we reach here normally */
    pthread_cleanup_pop(1);  /* 1 = execute handler */
    return NULL;
}

int main(void) {
    pthread_t tid;
    pthread_create(&tid, NULL, worker, NULL);

    sleep(3);  /* let worker run a bit */

    printf("Main: cancelling worker\n");
    pthread_cancel(tid);

    void *retval;
    pthread_join(tid, &retval);
    if (retval == PTHREAD_CANCELED)
        printf("Main: worker was cancelled\n");

    return 0;
}

Worker: starting long operation...
Worker: iteration 0
Worker: iteration 1
Main: cancelling worker
Cleanup: freeing allocated buffer
Main: worker was cancelled
(Number of iterations before cancel varies)

Key Points

•pthread_cancel requests termination at the next cancellation point
•Deferred (default): only cancelled at defined points (read, write, sleep, etc.)
•Cleanup handlers ensure resource release on cancellation
•push/pop must be paired in the same lexical scope
•Cancelled thread returns PTHREAD_CANCELED to pthread_join

Gotchas

•PTHREAD_CANCEL_ASYNCHRONOUS is almost impossible to use safely
•pthread_cleanup_push/pop are macros that expand to { and } -- must match scope
•Cancellation during mutex hold leaves the mutex locked -- use cleanup to unlock
•C++ exceptions and pthread cancellation interact poorly -- use C++ thread cancellation mechanisms instead

pthread_cancel(tid) requests termination. Deferred (default): only at cancellation points (read, sleep, etc.). Use cleanup_push/pop to free resources. Cancelled thread returns PTHREAD_CANCELED to joiner.

•Deferred: cancel only at cancellation points
•Cleanup handlers free resources

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

void cleanup(void *p) { free(p); }

void *worker(void *a) {
    (void)a;
    char *buf = malloc(100);
    pthread_cleanup_push(cleanup, buf);
    while (1) sleep(1);  /* cancellation point */
    pthread_cleanup_pop(1);
    return NULL;
}

push/pop must be matched in same scope

Question 11 / 15

What is the difference between thread safety and reentrancy?

Thread safety and reentrancy are related but different concepts:

Thread-safe function:

Can be called concurrently by multiple threads without causing data corruption
May use synchronization (mutexes, locks) to protect shared state
Example: malloc() is thread-safe (uses internal locks)

Reentrant function:

Can be safely interrupted (e.g., by a signal) and called again before the first invocation completes
Does NOT use any global or static data
Does NOT call non-reentrant functions
Example: strtok_r() is reentrant (takes explicit state parameter)

Key relationship:

All reentrant functions are thread-safe (no shared state = no conflicts)
NOT all thread-safe functions are reentrant (locks can cause deadlock if interrupted)

Example: strtok vs strtok_r:

strtok() uses a static internal pointer -- not thread-safe, not reentrant
strtok_r() takes an explicit save pointer -- reentrant and thread-safe

Making functions thread-safe:

Use local variables instead of static/global
Use thread-specific data (TSD)
Use mutexes to protect shared state
Provide _r variants with explicit state parameters

Pseudo Code

NOT thread-safe, NOT reentrant:
  char *strtok(char *str, const char *delim) {
    static char *save;  // shared state!
    // ...
  }

Thread-safe (with lock), NOT reentrant:
  void increment(void) {
    pthread_mutex_lock(&mtx);  // signal -> handler -> increment -> DEADLOCK
    counter++;
    pthread_mutex_unlock(&mtx);
  }

Reentrant AND thread-safe:
  char *strtok_r(char *str, const char *delim, char **saveptr) {
    // uses *saveptr instead of static variable
  }

Code

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

/* NOT thread-safe: static internal state */
void demo_strtok(const char *input) {
    char buf[128];
    strncpy(buf, input, sizeof(buf) - 1);
    buf[sizeof(buf) - 1] = '\0';
    char *token = strtok(buf, " ");
    while (token) {
        printf("%s\n", token);
        token = strtok(NULL, " ");
    }
}

/* Thread-safe AND reentrant: explicit state */
void demo_strtok_r(const char *input) {
    char buf[128];
    strncpy(buf, input, sizeof(buf) - 1);
    buf[sizeof(buf) - 1] = '\0';
    char *saveptr;  /* caller provides state */
    char *token = strtok_r(buf, " ", &saveptr);
    while (token) {
        printf("%s\n", token);
        token = strtok_r(NULL, " ", &saveptr);
    }
}

/* Thread-safe via mutex (but NOT reentrant) */
static int counter = 0;
static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;

void safe_increment(void) {
    pthread_mutex_lock(&mtx);
    counter++;  /* protected */
    pthread_mutex_unlock(&mtx);
    /* If a signal handler called safe_increment while lock is held
       -> DEADLOCK (not reentrant) */
}

int main(void) {
    demo_strtok_r("hello world foo");
    return 0;
}

hello
world
foo

Key Points

•Thread-safe: safe for concurrent calls (may use locks)
•Reentrant: safe for interruption and re-call (no shared state, no locks)
•All reentrant functions are thread-safe; not vice versa
•Use _r variants (strtok_r, ctime_r, etc.) for reentrant versions
•Reentrant is a stronger guarantee than thread-safe

Gotchas

•A function using a mutex is thread-safe but NOT reentrant (signal handler could deadlock)
•strtok, ctime, localtime, readdir are NOT thread-safe -- use _r variants
•errno was historically a global variable, now thread-local (thread-safe)
•printf is thread-safe (locked internally) but not reentrant

Thread-safe: safe for concurrent calls (may use locks). Reentrant: safe for interrupted re-call (no static state, no locks). Reentrant implies thread-safe, but not vice versa. Use _r variants (strtok_r, etc.).

•Reentrant > thread-safe (stronger guarantee)
•Use _r variants for reentrant functions

#include <string.h>
#include <stdio.h>

int main(void) {
    char buf[] = "a b c";
    char *save;
    /* strtok_r: reentrant + thread-safe */
    char *tok = strtok_r(buf, " ", &save);
    while (tok) {
        printf("%s\n", tok);
        tok = strtok_r(NULL, " ", &save);
    }
    return 0;
}

a
b
c

Mutex-protected code is thread-safe but not reentrant

Question 12 / 15

What is a race condition, and can you give a concrete example?

A race condition occurs when the behavior of a program depends on the relative timing of events (e.g., thread scheduling). The outcome is non-deterministic.

A data race is a specific type of race condition where two or more threads access the same memory location concurrently, at least one access is a write, and no synchronization is used. Data races are undefined behavior in C11.

Classic example -- lost update:

Thread A: read counter (value = 5)
Thread B: read counter (value = 5)
Thread A: write counter = 5 + 1 = 6
Thread B: write counter = 5 + 1 = 6  (should be 7!)

Both threads read the same value before either writes back, so one increment is lost.

Why it is hard to debug:

May not manifest in testing (timing-dependent)
May only appear under heavy load or on different hardware
Can produce different wrong results each run

Detection tools:

ThreadSanitizer (-fsanitize=thread)
Valgrind Helgrind/DRD
Code review focusing on shared mutable state

Pseudo Code

Race condition (lost update):
  counter = 5
  Thread A: temp_a = counter  (5)
  Thread B: temp_b = counter  (5)
  Thread A: counter = temp_a + 1 = 6
  Thread B: counter = temp_b + 1 = 6  // WRONG! Should be 7

Fix:
  Thread A: lock(mutex); counter++; unlock(mutex)
  Thread B: lock(mutex); counter++; unlock(mutex)
  // counter = 7 (correct)

Code

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

#define NTHREADS 10
#define ITERATIONS 1000000

static int counter = 0;
static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;

/* BUGGY: data race on counter */
void *unsafe_increment(void *arg) {
    (void)arg;
    for (int i = 0; i < ITERATIONS; i++)
        counter++;  /* NOT atomic: read + modify + write */
    return NULL;
}

/* CORRECT: mutex-protected */
void *safe_increment(void *arg) {
    (void)arg;
    for (int i = 0; i < ITERATIONS; i++) {
        pthread_mutex_lock(&mtx);
        counter++;
        pthread_mutex_unlock(&mtx);
    }
    return NULL;
}

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

    /* Unsafe version */
    counter = 0;
    for (int i = 0; i < NTHREADS; i++)
        pthread_create(&threads[i], NULL, unsafe_increment, NULL);
    for (int i = 0; i < NTHREADS; i++)
        pthread_join(threads[i], NULL);
    printf("Unsafe: %d (expected %d)\n", counter, NTHREADS * ITERATIONS);
    /* Typically less than expected */

    /* Safe version */
    counter = 0;
    for (int i = 0; i < NTHREADS; i++)
        pthread_create(&threads[i], NULL, safe_increment, NULL);
    for (int i = 0; i < NTHREADS; i++)
        pthread_join(threads[i], NULL);
    printf("Safe:   %d (expected %d)\n", counter, NTHREADS * ITERATIONS);
    /* Exactly expected */

    return 0;
}

Unsafe: <value less than 10000000> (expected 10000000)
Safe:   10000000 (expected 10000000)
(Unsafe value varies due to race condition)

Key Points

•Race condition: outcome depends on thread scheduling timing
•Data race: concurrent unsynchronized access with at least one write
•counter++ is NOT atomic (read-modify-write = 3 operations)
•Fix with mutex, or C11 atomic_int
•Detect with -fsanitize=thread or Valgrind Helgrind

Gotchas

•Data races are undefined behavior in C11 (anything can happen)
•Race conditions may not manifest in testing but crash in production
•Even simple operations like ++ and = can race on multi-core CPUs
•Volatile does NOT prevent data races (it only prevents compiler optimization)

Race condition: program correctness depends on thread timing. Classic: counter++ by two threads (read-modify-write is not atomic). Fix: mutex or atomics. Detect: -fsanitize=thread.

•counter++ is not atomic
•Fix with mutex or atomics

#include <pthread.h>

int count = 0;
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;

void *bad(void *a)  { (void)a; for(int i=0;i<1000000;i++) count++;        return NULL; }
void *good(void *a) { (void)a; for(int i=0;i<1000000;i++) { pthread_mutex_lock(&m); count++; pthread_mutex_unlock(&m); } return NULL; }

volatile does NOT prevent data races

Question 13 / 15

How do C11 atomic operations work (stdatomic.h)?

C11 introduced <stdatomic.h> for lock-free atomic operations, eliminating data races without mutexes for simple operations.

Atomic types:

#include <stdatomic.h>
atomic_int counter = 0;
atomic_flag lock = ATOMIC_FLAG_INIT;
_Atomic int x;  /* generic syntax */

Key operations:

atomic_store(&var, value);         /* atomic write */
int v = atomic_load(&var);         /* atomic read */
atomic_fetch_add(&var, 1);         /* atomic increment, returns old value */
atomic_fetch_sub(&var, 1);         /* atomic decrement */
atomic_compare_exchange_strong(&var, &expected, desired); /* CAS */

Memory ordering (optional parameter):

memory_order_relaxed -- no ordering guarantees (just atomicity)
memory_order_acquire -- subsequent reads see all writes from the releasing thread
memory_order_release -- prior writes visible to acquiring threads
memory_order_seq_cst -- sequential consistency (default, strongest)

When to use atomics vs mutexes:

Atomics: simple counters, flags, single-variable operations
Mutexes: compound operations involving multiple variables
Lock-free algorithms: use CAS (compare-and-swap) for complex patterns

Atomics are typically faster than mutexes for simple operations because they use hardware instructions (e.g., lock xadd on x86) without kernel involvement.

Pseudo Code

Without atomics (data race):
  counter++  ->  temp = counter; temp++; counter = temp;
  // Two threads can read same value -> lost update

With atomics (no data race):
  atomic_fetch_add(&counter, 1)
  // Single hardware instruction, no race possible

CAS (compare and swap):
  expected = atomic_load(&var);
  desired = expected + 1;
  atomic_compare_exchange_strong(&var, &expected, desired);
  // Sets var=desired only if var==expected, atomically

Code

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

#define NTHREADS 10
#define ITERATIONS 1000000

static atomic_int counter = 0;

void *increment(void *arg) {
    (void)arg;
    for (int i = 0; i < ITERATIONS; i++)
        atomic_fetch_add(&counter, 1);  /* lock-free, no mutex */
    return NULL;
}

/* Spinlock using atomic_flag */
static atomic_flag spinlock = ATOMIC_FLAG_INIT;
static int protected_data = 0;

void spin_lock(atomic_flag *lock) {
    while (atomic_flag_test_and_set(lock))  /* returns old value */
        ;  /* spin */
}

void spin_unlock(atomic_flag *lock) {
    atomic_flag_clear(lock);
}

void *spin_worker(void *arg) {
    (void)arg;
    for (int i = 0; i < 100000; i++) {
        spin_lock(&spinlock);
        protected_data++;
        spin_unlock(&spinlock);
    }
    return NULL;
}

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

    /* Atomic counter (no mutex needed) */
    for (int i = 0; i < NTHREADS; i++)
        pthread_create(&threads[i], NULL, increment, NULL);
    for (int i = 0; i < NTHREADS; i++)
        pthread_join(threads[i], NULL);
    printf("Atomic counter: %d (expected %d)\n",
           atomic_load(&counter), NTHREADS * ITERATIONS);

    /* Spinlock example */
    for (int i = 0; i < NTHREADS; i++)
        pthread_create(&threads[i], NULL, spin_worker, NULL);
    for (int i = 0; i < NTHREADS; i++)
        pthread_join(threads[i], NULL);
    printf("Spinlock data: %d (expected %d)\n",
           protected_data, NTHREADS * 100000);

    return 0;
}

Atomic counter: 10000000 (expected 10000000)
Spinlock data: 1000000 (expected 1000000)

Key Points

•C11 stdatomic.h provides lock-free atomic operations
•atomic_fetch_add/sub are hardware-level atomic read-modify-write
•Default memory order is seq_cst (strongest, safest)
•Faster than mutexes for simple counters and flags
•atomic_flag + test_and_set can implement a spinlock

Gotchas

•Atomics only protect single variables -- use mutexes for multi-variable invariants
•Relaxed memory ordering is tricky and error-prone -- stick with seq_cst unless profiling shows need
•Not all types can be lock-free on all platforms (check atomic_is_lock_free)
•Spinlocks waste CPU -- only use when lock hold time is very short

C11 <stdatomic.h>: atomic_int, atomic_fetch_add(), atomic_load(), atomic_store(). Lock-free, faster than mutexes for simple operations. Default memory order: sequential consistency.

•atomic_fetch_add is a single hardware instruction
•No mutex needed for simple counters

#include <stdatomic.h>
#include <pthread.h>

atomic_int counter = 0;

void *func(void *a) {
    (void)a;
    for (int i = 0; i < 1000000; i++)
        atomic_fetch_add(&counter, 1);  /* lock-free */
    return NULL;
}

Only protects single variables, not multi-variable invariants

Question 14 / 15

What is a thread pool pattern, and how would you implement one in C?

A thread pool is a set of pre-created worker threads that pull tasks from a shared work queue. This avoids the overhead of creating and destroying threads for each task.

Components:

Work queue: A linked list or array of pending tasks (function pointer + argument)
Worker threads: Fixed number of threads that loop: take task from queue, execute, repeat
Mutex: Protects the work queue
Condition variable: Workers wait when queue is empty
Shutdown flag: Signals workers to exit

Advantages:

Bounded thread count (prevents thread explosion)
Amortized thread creation cost
Controlled concurrency level
Reuse of threads across tasks

Usage pattern:

pool = threadpool_create(num_threads);
threadpool_submit(pool, task_function, task_arg);
...
threadpool_destroy(pool);  /* signal shutdown, join all threads */

Pseudo Code

Worker thread loop:
  lock(mutex)
  while (queue is empty AND not shutdown)
    cond_wait(not_empty, mutex)
  if (shutdown) { unlock; return; }
  task = dequeue()
  unlock(mutex)
  task.function(task.arg)  // execute task
  goto loop

Submit task:
  lock(mutex)
  enqueue(task)
  cond_signal(not_empty)  // wake one worker
  unlock(mutex)

Shutdown:
  lock(mutex)
  shutdown = true
  cond_broadcast(not_empty)  // wake all workers
  unlock(mutex)
  join all threads

Code

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

typedef struct task {
    void (*function)(void *arg);
    void *arg;
    struct task *next;
} task_t;

typedef struct {
    pthread_t *threads;
    int thread_count;
    task_t *queue_head;
    task_t *queue_tail;
    pthread_mutex_t mutex;
    pthread_cond_t not_empty;
    int shutdown;
} threadpool_t;

void *worker(void *arg) {
    threadpool_t *pool = (threadpool_t *)arg;
    for (;;) {
        pthread_mutex_lock(&pool->mutex);
        while (pool->queue_head == NULL && !pool->shutdown)
            pthread_cond_wait(&pool->not_empty, &pool->mutex);

        if (pool->shutdown && pool->queue_head == NULL) {
            pthread_mutex_unlock(&pool->mutex);
            return NULL;
        }

        task_t *task = pool->queue_head;
        pool->queue_head = task->next;
        if (pool->queue_head == NULL) pool->queue_tail = NULL;
        pthread_mutex_unlock(&pool->mutex);

        task->function(task->arg);
        free(task);
    }
}

threadpool_t *threadpool_create(int num_threads) {
    threadpool_t *pool = calloc(1, sizeof(threadpool_t));
    pool->thread_count = num_threads;
    pool->threads = malloc(sizeof(pthread_t) * (size_t)num_threads);
    pthread_mutex_init(&pool->mutex, NULL);
    pthread_cond_init(&pool->not_empty, NULL);
    for (int i = 0; i < num_threads; i++)
        pthread_create(&pool->threads[i], NULL, worker, pool);
    return pool;
}

void threadpool_submit(threadpool_t *pool, void (*fn)(void*), void *arg) {
    task_t *task = malloc(sizeof(task_t));
    task->function = fn;
    task->arg = arg;
    task->next = NULL;
    pthread_mutex_lock(&pool->mutex);
    if (pool->queue_tail)
        pool->queue_tail->next = task;
    else
        pool->queue_head = task;
    pool->queue_tail = task;
    pthread_cond_signal(&pool->not_empty);
    pthread_mutex_unlock(&pool->mutex);
}

void threadpool_destroy(threadpool_t *pool) {
    pthread_mutex_lock(&pool->mutex);
    pool->shutdown = 1;
    pthread_cond_broadcast(&pool->not_empty);
    pthread_mutex_unlock(&pool->mutex);
    for (int i = 0; i < pool->thread_count; i++)
        pthread_join(pool->threads[i], NULL);
    free(pool->threads);
    pthread_mutex_destroy(&pool->mutex);
    pthread_cond_destroy(&pool->not_empty);
    free(pool);
}

/* Example task */
void print_task(void *arg) {
    int n = *(int *)arg;
    printf("Task %d on thread %lu\n", n, (unsigned long)pthread_self());
    free(arg);
}

int main(void) {
    threadpool_t *pool = threadpool_create(4);
    for (int i = 0; i < 20; i++) {
        int *n = malloc(sizeof(int));
        *n = i;
        threadpool_submit(pool, print_task, n);
    }
    sleep(1);
    threadpool_destroy(pool);
    return 0;
}

Task 0 on thread <id>
Task 1 on thread <id>
...
Task 19 on thread <id>
(Task order and thread IDs vary; all 20 tasks execute)

Key Points

•Thread pool: fixed worker threads + shared task queue
•Workers wait on condvar when queue is empty
•Submit enqueues a task and signals one worker
•Shutdown: set flag, broadcast to wake all, join all threads
•Avoids thread creation overhead for frequent short tasks

Gotchas

•Must use broadcast (not signal) for shutdown to wake ALL waiting workers
•Memory management: who frees task arguments? (caller or task function)
•Queue can grow unbounded if tasks arrive faster than processed -- consider queue limits
•Worker should check shutdown AFTER waking, even if queue is non-empty

Thread pool: pre-created worker threads loop on a shared task queue. Mutex + condvar for synchronization. submit() enqueues + signals; workers dequeue + execute. destroy() sets shutdown flag + broadcast + join.

•Fixed threads + shared queue
•Avoids per-task thread creation overhead

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

typedef struct { void (*fn)(void*); void *arg; } task_t;
/* Workers: lock, while(empty && !shutdown) wait, dequeue, unlock, execute */
/* Submit: lock, enqueue, signal, unlock */
/* Destroy: lock, shutdown=1, broadcast, unlock, join all */

Use broadcast for shutdown, not signal

Question 15 / 15

What are common pthreads interview problems and how do you solve them?

Common pthreads interview problems test understanding of synchronization primitives:

1. Print alternating (Thread A prints odd, Thread B prints even): Use a mutex + condvar + shared turn variable. Each thread waits for its turn.

2. Dining Philosophers: N philosophers sit around a table with N forks. Each needs two forks to eat. Solve with lock ordering (always pick up lower-numbered fork first) or a mutex that limits concurrent eaters.

3. Reader-Writer Problem: Multiple readers can read concurrently, but writers need exclusive access. Use rwlocks or implement with mutex + condvar + reader count.

4. Barrier (all threads wait until all arrive): Use pthread_barrier_t or implement with mutex + condvar + count.

5. H2O Problem (Google): Threads represent H or O atoms. Must form groups of 2H + 1O before any can proceed. Use semaphores or condvars.

6. Bounded Buffer (Producer-Consumer): See separate answer on producer-consumer pattern.

The key insight for all these problems: identify the shared state, determine the invariant that must hold, and use the minimal synchronization to enforce it.

Pseudo Code

Print 1-10 alternating between two threads:
  int turn = 1;  // odd thread goes first
  
  odd_thread:
    for n = 1,3,5,7,9:
      lock(mutex)
      while (turn != 1) wait(cond, mutex)
      print(n)
      turn = 2
      signal(cond)
      unlock(mutex)

  even_thread:
    for n = 2,4,6,8,10:
      lock(mutex)
      while (turn != 2) wait(cond, mutex)
      print(n)
      turn = 1
      signal(cond)
      unlock(mutex)

Code

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

/* Problem: Print 1-20 alternating between two threads */
static int number = 1;
static int turn = 1;  /* 1 = odd's turn, 2 = even's turn */
static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

void *print_odd(void *arg) {
    (void)arg;
    while (1) {
        pthread_mutex_lock(&mtx);
        while (turn != 1 && number <= 20)
            pthread_cond_wait(&cond, &mtx);
        if (number > 20) {
            pthread_mutex_unlock(&mtx);
            break;
        }
        printf("Odd thread:  %d\n", number++);
        turn = 2;
        pthread_cond_signal(&cond);
        pthread_mutex_unlock(&mtx);
    }
    return NULL;
}

void *print_even(void *arg) {
    (void)arg;
    while (1) {
        pthread_mutex_lock(&mtx);
        while (turn != 2 && number <= 20)
            pthread_cond_wait(&cond, &mtx);
        if (number > 20) {
            pthread_mutex_unlock(&mtx);
            break;
        }
        printf("Even thread: %d\n", number++);
        turn = 1;
        pthread_cond_signal(&cond);
        pthread_mutex_unlock(&mtx);
    }
    return NULL;
}

int main(void) {
    pthread_t t1, t2;
    pthread_create(&t1, NULL, print_odd, NULL);
    pthread_create(&t2, NULL, print_even, NULL);
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    printf("Done: printed 1-20 alternating\n");
    return 0;
}

Odd thread:  1
Even thread: 2
Odd thread:  3
Even thread: 4
...
Odd thread:  19
Even thread: 20
Done: printed 1-20 alternating

Key Points

•Alternating print: mutex + condvar + turn variable
•Dining philosophers: lock ordering on forks prevents deadlock
•Reader-writer: rwlock or manual implementation with condvar
•All problems: identify shared state, determine invariant, enforce with minimal sync
•Common mistake: using if instead of while for cond_wait

Gotchas

•Termination: both threads must check the exit condition under the lock
•Use broadcast (not signal) when multiple threads might need to wake up
•The turn variable must be checked in a while loop (spurious wakeups)
•Dining philosophers: picking up both forks atomically (lock ordering) is the simplest solution

Common problems: alternating print (mutex+condvar+turn), dining philosophers (lock ordering), producer-consumer (bounded buffer+condvar), barrier (count+condvar). Key: identify shared state, enforce invariant with minimal synchronization.

•Turn variable + condvar for ordering
•Lock ordering for deadlock prevention

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

int turn = 1;
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t c = PTHREAD_COND_INITIALIZER;

void *odd(void *a) {
    (void)a;
    for (int i=1; i<=9; i+=2) {
        pthread_mutex_lock(&m);
        while(turn!=1) pthread_cond_wait(&c,&m);
        printf("%d ",i); turn=2;
        pthread_cond_signal(&c);
        pthread_mutex_unlock(&m);
    }
    return NULL;
}

Always while-loop on cond_wait

Built by onllm.dev

Home GitHub Support awesomePrep