Advanced Programming in the UNIX Environment (APUE)
Stevens/Rago (2005)

Book review by Ted Felix

I've always wanted to read this one to figure out what all those inter-process communication things are for. You know, things like semaphores and mutexes (mutices?). I've done multi-threading and multi-processing before, but never really gave myself a good education in the options that are available. This book looks like what I need. Perhaps a book on operating systems would be better as it is the theory and rationale that interests me most. However, this looks like a really fun book to read anyway.

Overall, a great book. The first 17 chapters were very relevant even for Windows programmers. I lost interest from chapters 18 through 21 as they covered some rather Unix-specific things. I mainly read the book for chapters 11 through 17 which covered threads, processes, and communication between threads and processes. This section was great, and clarified all the various interesting mechanisms available for coordinating processes and threads.

• Mutexes (pg 370) (thread and process) - Simple exclusive locks
• Reader-writer locks (pg 378) (thread and process) - Locks that allow for shared and exclusive locking
• Condition Variables (pg 382) (thread and process) - Allow a thread or process to wait for an event from another thread or process
• Pipes 15.2 (process) - Two processes sit on either end of what looks like a file. What one writes, the other reads. Must be set up by a parent process. We've all used this in the command shell via the "|" pipe character.
• FIFO 15.5 (process) - Similar to a pipe, but is mapped to a filename in the filesystem, making it easy to find.
• Message Queues 15.7 (process) - Problematic, and should be avoided.
• Semaphores 15.8 (process) - A counted mutex. Each lock decrements a counter. When its counter reaches 0, no more locks are granted. With an initial counter value of 1, this is a mutex. Mutexes are easier to use, as are file locks.
• Shared Memory 15.9 (process) - Fastest form of IPC. Note that threads already share all their memory, so coming up with thread-private storage is more of an issue.
• File Locking (pg 532-533) - The filesystem locking mechanism makes a perfect inter-process reader-writer lock.
• IP Sockets 16 (process and machine) - De facto standard for machine to machine communication.
• Unix Domain Sockets 17.3 (process) - Faster than IP, but limited to the local machine.

It struck me as I was reading this that all this IPC stuff boils down to atomic operations, shared memory, and the ability to wait for another thread or process to tell you to go (condition variables). That's all you need to implement all the various mechanisms.

This book inspired me to take a look at the Linux source code to see how Mutexes are implemented. Turns out on the Intel processors (486 and later), an interlocked compare and exchange is used through the "LOCK" instruction and the atomic "CMPXCHG" instruction. Then, the process scheduler is called for blocking when needed.

Next, I would like to read a Windows-specific threading book (I have Beveridge and Wiener Multithreading Applications in Win32), and then a more theoretical book on multi-tasking mechanisms.

Read from 1/14/2006 to 2/17/2006.

<- Back to my software books page.