
Explore how a process owns memory and resources, while threads share that memory but have their own stacks, and learn how the OS uses PCB and TCB to manage them.
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.
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.
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.
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.
In today’s computing world, concurrency is no longer optional — it’s essential. Modern applications must be fast, responsive, and capable of handling multiple tasks at once. This course is designed to give you a deep, practical understanding of multithreading programming in C using POSIX threads (pthreads) and futex, the powerful Linux system call for user-space synchronization.
Whether you're a systems programmer, embedded developer, Linux enthusiast, or computer science student, this course will walk you through every essential concept you need — starting from the basics and building up to low-level, high-performance techniques used in real-world software.
You'll begin by exploring the difference between processes and threads, understand why multithreading is more efficient, and learn how to create, manage, and terminate threads safely. From there, we’ll dive into synchronization tools like mutexes, condition variables, spinlocks, barriers, and advanced topics such as deadlocks, thread-local storage, reentrant functions, and thread safety.
In the second half of the course, you’ll learn how to use futex (Fast Userspace Mutex) — a Linux kernel mechanism for fast, scalable thread synchronization. We’ll explore futex APIs, fast vs. slow paths, kernel-level optimizations, and how futex is used under the hood by libraries like glibc and pthreads.
You’ll also analyze memory layout, thread stacks, how signals behave in multithreaded environments, and the difference between user and kernel space when working with threads.
By the end of this course, you’ll be able to write robust, thread-safe, and high-performance multithreaded applications in C — with a deep understanding of what’s happening behind the scenes at the kernel level.