While Volume 1 focused on Networking (communicating across a network), Volume 2 focuses on IPC (processes communicating on the same system). [cite_start]We are skipping Part 2 (Message Passing like Pipes/Queues) for now and diving straight into Part 3: Synchronization.
Core Objective: Synchronization
In the previous chapters (Volume 1), we often relied on the operating system to handle the flow of data (e.g., read blocks if there is no data). However, when processes or threads share a piece of memory (like a global variable or a shared memory segment), the OS doesn’t automatically protect that memory from being accessed by two people at the same time.
1. The Building Blocks
Stevens introduces two primary tools that usually go hand-in-hand:
- Mutexes (Mutual Exclusion): Used to lock a resource so only one thread can access it at a time.
- Condition Variables: Used to wait for something to happen (like waiting for data to arrive in a buffer).
2. Threads vs. Processes
An important distinction made in this introduction is the scope of these tools:
- Threads: Mutexes and Condition Variables are native to the Posix.1 threads standard (Pthreads). They are always available to synchronize threads within a single process.
- Processes: They can also be used to synchronize different processes, provided the mutex or condition variable is stored in shared memory that both processes can access.
3. The Running Example: Producer-Consumer
To illustrate these concepts, the book introduces the Producer-Consumer Problem.
- Producer: Generates data and places it into a buffer.
- Consumer: Takes data from the buffer and processes it.
- The Challenge: We must ensure the producer doesn’t overwrite data the consumer hasn’t read yet, and the consumer doesn’t try to read an empty buffer.
Note on the Examples: The book explicitly chooses to use threads for the examples in this chapter. This is because sharing a global array between threads is trivial (it’s automatic), whereas setting up shared memory between processes is more verbose. [cite_start]This allows us to focus purely on the synchronization logic.