C pthreads Intro

Threads vs processes

• Processes have separate memory; to communicate they need IPC.
• Threads in the same process share memory, which is cheap — but means you must guard against data races.
• On a multi-core CPU, multiple threads truly run in parallel.

pthread_create / join

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

// Thread entry point: both arg and return are void*
void *worker(void *arg) {
    int id = *(int *)arg;
    printf("hello from thread %d\n", id);
    return NULL;
}

int main(void) {
    pthread_t t1, t2;
    int a = 1, b = 2;

    pthread_create(&t1, NULL, worker, &a);
    pthread_create(&t2, NULL, worker, &b);

    pthread_join(t1, NULL);  // wait for t1
    pthread_join(t2, NULL);

    printf("main done\n");
    return 0;
}

Receiving a return value

void *compute(void *arg) {
    int x = *(int *)arg;
    int *result = malloc(sizeof(int));
    *result = x * x;
    return result;
}

// in main:
void *ret;
pthread_join(t, &ret);
printf("result = %d\n", *(int *)ret);
free(ret);

Data races (demo)

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

#define N 4
#define LOOPS 1000000

long counter = 0;         // shared

void *worker(void *arg) {
    for (int i = 0; i < LOOPS; i++) {
        counter++;              // NOT atomic!
    }
    return NULL;
}

int main(void) {
    pthread_t th[N];
    for (int i = 0; i < N; i++)
        pthread_create(&th[i], NULL, worker, NULL);
    for (int i = 0; i < N; i++)
        pthread_join(th[i], NULL);

    printf("expected: %d\n", N * LOOPS);
    printf("actual:   %ld\n", counter);
    return 0;
}

Fix with mutex

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

#define N 4
#define LOOPS 1000000

long counter = 0;
pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;

void *worker(void *arg) {
    for (int i = 0; i < LOOPS; i++) {
        pthread_mutex_lock(&mtx);
        counter++;
        pthread_mutex_unlock(&mtx);
    }
    return NULL;
}

int main(void) {
    pthread_t th[N];
    for (int i = 0; i < N; i++)
        pthread_create(&th[i], NULL, worker, NULL);
    for (int i = 0; i < N; i++)
        pthread_join(th[i], NULL);

    printf("counter = %ld\n", counter);  // always 4000000
    pthread_mutex_destroy(&mtx);
    return 0;
}

For simple counters, atomics are faster

#include <stdatomic.h>

atomic_long counter = 0;

// in worker:
atomic_fetch_add(&counter, 1);   // safe, lock-free

Avoiding deadlock

// BAD: different lock orders per thread
// Thread A: lock(m1) → lock(m2)
// Thread B: lock(m2) → lock(m1)
// → both hold one and wait for the other

Strategies

1. Unify the order — assign numbers to mutexes and always lock lowest first. No cycle is possible.
2. trylock — pthread_mutex_trylock fails instead of waiting. If you can't grab the second lock, release the first and retry.
3. Use fewer locks — one well-scoped lock is usually simpler than several fine-grained ones.

Challenges