POSIX Multithreading and Futex Programming in C From Scratch

Learn how POSIX threads enable multi-threading in Unix by creating new threads with pthread_create (four arguments: the thread id, attributes, the thread function, and its argument), and synchronize with pthread_join.

Explore how threads terminate in POSIX programs: returning from a thread function, pthread_exit, and thread cancellation, and how process termination versus main thread exit affects remaining threads and joinability.

Join POSIX threads to wait for a specific thread to finish, reclaim resources, and retrieve return values, while understanding joinable vs detached threads.

Explore POSIX thread detaching, distinguishing joinable and detached threads, how to detach or create detached threads, and why joining a detached thread is invalid.

Explore POSIX thread cancellation, including cancellation state and type, deferred cancellation, cleanup handlers, cancellation points, and safe resource cleanup to prevent leaks and deadlocks.

Learn atomic programming and race-condition prevention using atomic operations, mutexes, and hardware or GCC built-ins, while avoiding volatile and safely updating a shared counter in multi-threaded code.

Explore POSIX multithreading with mutex locks to prevent race conditions when multiple threads update a shared counter, using pthread mutex lock and unlock for correct increments.

Master posix mutexes for safe shared resource access, covering static vs dynamic locks, trylock, and timed lock to prevent deadlocks.

This lecture explains deadlocks in multithreading—mutual exclusion, hold and wait, no preemption, and circular wait—and offers fixes like fixed-order locking and banker's algorithm.

Explore POSIX reader-writer locks, enabling multiple concurrent readers with a single writer, using read and write locks, initialization, destruction, and scenarios where reads predominate over writes.

Configure mutex attributes to tailor lock behavior, enabling recursive locks, process sharing, and priority inheritance for robust multi-threaded synchronization.

Explore how condition variables coordinate threads with a mutex to wait for conditions, using pthread cond wait, signal, and broadcast, including timed waits and preventing missed signals and spurious wakeups.

Master the producer-consumer problem by using a mutex and condition variables to coordinate a shared buffer, avoid deadlocks and race conditions, and ensure fair scheduling for multiple threads.

Learn to implement spinlocks for ultra-fast, low-latency locking using pthread spin APIs, balancing busy-wait benefits against potential CPU waste and fairness concerns in real-time and kernel contexts.

Learn how barriers synchronize multiple threads using POSIX threads, ensuring all threads reach a checkpoint before continuing, preventing race conditions in parallel computing and simulations.

Understand thread safety to prevent data corruption when multiple threads access shared resources. Use mutexes and read-write locks to stop race conditions, deadlocks, and priority inversion, coordinating readers and writers.

Identify re-entrant versus non-re-entrant functions in POSIX multithreading, and learn safe approaches like thread local storage, mutexes, and f lock file for thread-safe I/O.

Learn how to implement per-thread storage with tsd APIs in posix threads, creating unique keys, storing and retrieving thread-specific data, using destructors, and ensuring automatic cleanup.

Explore the thread-specific data API to give each thread its own strerror buffer, preventing data races, avoiding locks, and automatically cleaning up memory as threads exit.

Explore thread local storage and how Linux imposes thread limits, then implement tlc with pthread keys or __thread and thread_local, including dynamic per-thread data and destructor cleanup.

Discover how each thread gets its own stack to store locals and return addresses, and how to configure default and custom sizes with guard pages and ASan.

Explore how signals interact with threads, including process-wide versus thread-specific behavior, and learn safe handling with a dedicated signal-handling thread using pthreads and sigaction.

Explain the difference between user space and kernel space, why isolation protects the system, and how system calls bridge the two worlds, with context switches and performance implications.

Explore the history of futex, a hybrid Linux synchronization that runs most locks in userspace and uses the kernel only when contention occurs, reducing kernel mode transactions.

Differentiate the fast path as the highway of execution, optimized for speed. Apply fast-path techniques like vdso and mmap to avoid calls, minimize locks, and bypass kernel networking.

Explore futex system call API for fast userspace synchronization in Linux, keeping most work in user space and only invoking the kernel when contention arises to boost performance.

Implement a basic mutex from scratch using Linux futexes, atomic operations, and futex wait/wake wrappers to demonstrate low-level locking and thread synchronization in C.

Implement a condition variable from scratch using futex, atomic operations, and system calls. Workers wait on the condition with a mutex; a signal thread wakes them, mirroring posix pthreads.

Explore efficient futex wake strategies for POSIX multithreading: avoid thundering herd, apply adaptive wakeups, use bitset and priority-based wakeups, and ensure real-time scheduling to prevent priority inversion and improve scalability.

Explore kernel-level optimizations of futex synchronization in Linux, including userspace fastpath, kernel slow path handling, and efficient wakeups via hashing, wake queues, and adaptive scheduling.

Explore futex and vertex hashing to manage contention by hashing vertex wait queues into buckets, enabling fastpath locking and wakeups with minimal kernel overhead.