Mastering POSIX Threads: From Basics to Advanced Synchronization

Why Threads Over Fork?

In the traditional Unix model, a process forks a child to handle tasks; this is expensive and requires inter‑process communication. Threads, also called lightweight processes, are faster and share memory, simplifying communication but introducing synchronization challenges.

Thread Basics

All threads in a process share global memory, file descriptors, signal handlers, and more, but each thread has its own ID, registers, stack, errno, and thread‑specific data. Linux implements POSIX threads (pthreads) via pthread.h and the libpthread library.

Key Data Types

pthread_t   // thread ID
pthread_attr_t // thread attributes

Essential Thread Functions

pthread_create()
pthread_exit()
pthread_cancel()
pthread_join()
pthread_attr_init()
pthread_attr_setdetachstate()
pthread_attr_getdetachstate()
pthread_attr_destroy()
pthread_kill()

Synchronization Primitives

Mutexes ( pthread_mutex_t) protect critical sections; functions include pthread_mutex_init, pthread_mutex_destroy, pthread_mutex_lock, pthread_mutex_trylock, and pthread_mutex_unlock. Reader‑writer locks ( pthread_rwlock_t) allow multiple readers or a single writer, with init/destroy and lock/unlock functions.

Condition variables ( pthread_cond_t) work with a mutex to block a thread until a condition is signaled. Functions: pthread_cond_init, pthread_cond_destroy, pthread_cond_wait, pthread_cond_timedwait, pthread_cond_signal, and pthread_cond_broadcast.

Thread Cleanup

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

These maintain a stack of cleanup handlers that run when a thread exits via pthread_exit, is cancelled, or when pthread_cleanup_pop is called with a non‑zero argument.

Thread Attributes

Attributes are set via a pthread_attr_t object initialized with pthread_attr_init. They control binding (scope), detach state, stack size, and scheduling priority. Example of creating a bound thread:

#include <pthread.h>
pthread_attr_t attr;
pthread_t tid;
pthread_attr_init(&attr);
pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM);
pthread_create(&tid, &attr, my_function, NULL);

Thread Detach and Join

A non‑detached thread’s exit status remains until another thread calls pthread_join. A detached thread releases resources immediately and cannot be joined. Detach a thread with pthread_detach or set the attribute before creation.

Example: Mutex‑Protected Producer/Consumer

void reader_function(void);
void writer_function(void);
char buffer;
int buffer_has_item = 0;
pthread_mutex_t mutex;
struct timespec delay;

int main(void) {
    pthread_t reader;
    delay.tv_sec = 2;
    delay.tv_nsec = 0;
    pthread_mutex_init(&mutex, NULL);
    pthread_create(&reader, NULL, (void*)reader_function, NULL);
    writer_function();
}

void writer_function(void) {
    while (1) {
        pthread_mutex_lock(&mutex);
        if (buffer_has_item == 0) {
            buffer = make_new_item();
            buffer_has_item = 1;
        }
        pthread_mutex_unlock(&mutex);
        pthread_delay_np(&delay);
    }
}

void reader_function(void) {
    while (1) {
        pthread_mutex_lock(&mutex);
        if (buffer_has_item == 1) {
            consume_item(buffer);
            buffer_has_item = 0;
        }
        pthread_mutex_unlock(&mutex);
        pthread_delay_np(&delay);
    }
}

Process vs Thread Diagram