Browse Books

Reviewer: John R. Levine

Every large computer (and many small ones) now has more than one CPU. The POSIX 1003.1-c pthread package permits programs to use these multiple processors in a reasonably portable way. Butenhof, one of the authors of the pthread standard, has written a complete and fairly accessible introduction to pthreads. He assumes that the reader is familiar with C programming and simple POSIX programming, but not with threads and parallel programming. The first few chapters introduce pthreads creation and management. Butenhof explains each concept using complete C programs, with program line numbers in the margin next to the explanatory text to help readers keep track of the programs. Chapter 3 addresses synchronization with mutexes and condition variables. Chapter 4 covers three styles of threaded programming—pipeline, work crew, and client/server. Chapter 5 covers a variety of more advanced topics, including storage management and processor scheduling. This completes the basics of pthreads, but it is only about half of the book. The remaining chapters are the more valuable part of the book; they discuss how to make pthreads work in connection with the rest of POSIX, which can be decidedly hostile to threads. Chapter 6 covers the interaction between threads and important POSIX facilities, including standard I/O, signals, and the many library routines that are not thread-safe. Chapter 7 goes into more practical aspects, such as more complex synchronization, queue managers, and wrapping existing libraries. Chapter 8 discusses debugging, and in particular how to avoid it, since thread debugging is so painful. Chapters 9 and 10 conclude with a reference summary of pthreads and a discussion of future standardization. All in all, I like this book. It is written in a clear and pleasantly informal first-person style. Some of the code examples are long, but necessarily so, and the explanations untangle them adequately. The practical information in the second half of the book is essential for effective pthreads programming, particularly for programmers who have not previously experienced the many new and exciting failure modes that threads adds to sequential code. The only area where I would have wanted more information is in planning thread granularity. Butenhof warns the reader not to make thread granularity too fine, in which case the program spends all its time in synchronization rather than in doing useful work, or too coarse, in which case programs are unresponsive and do not use all available processors. He does not give readers much help in figuring out where the happy medium lies, however. Despite these minor issues, this is an excellent introduction to pthreads programming, containing the encapsulated wisdom of one of the masters of the field.