Browse Books

Reviewer: Frank Lawrence Friedman

Serious programmers with an interest in or need for writing efficient programs are the audience for this book. The authors' objective is to provide a solid understanding of programming threads—what they are, how they work, and why they are useful. Once they have read this detailed book, most programmers will have a reasonably good start at writing multithreaded programs. They will also have gained a sufficient understanding of the purpose and value of threads to enable them to analyze programs and determine when multiple threads should be used. The book focuses on the POSIX multithreading model, but also provides sufficient information comparing the POSIX application programming interface (API) with the Win32 and OS/2 APIs to enable programmers to understand some of the portability issues involved in writing for different systems and system libraries. The authors first introduce shared memory multiprocessors and the interactions between threads and shared memory multiprocessors. They introduce the basic concept of a multitasking operating system and show why a multithreaded programming paradigm can be used more effectively and efficiently to write certain kinds of programs. Basic operating system support for multithreading is presented next. Invocation, lifetime, and termination details are discussed and illustrated using a small program. After this introductory material, serious details on multithreading begin with discussions of scheduling, synchronization, and signaling issues. Alternative programming designs for synchronization using threading, and complex issues such as context switching, use of synchronization variables, bounded-time termination, and program correctness are discussed. The last half of the book is concerned with less granular issues, such as the compilation of multithreaded programs, operating system libraries and related programming issues, and designs for programs and library functions (with code examples and discussions of tradeoffs). Performance and hardware issues are covered in the last few chapters. This material includes various designs for shared-memory symmetric processors (SMP machines) and discussions of how these designs affect programming design and coding decisions. Several complete programs are presented along with detailed discussions of how threads are used in these programs. References to other example programs on the Internet are given. The book is an excellent reference for serious programmers concerned with making more effective use of hardware architectures (that is, with writing faster programs better, more easily, and with fewer bugs). Many of the concepts presented are applicable to any shared memory multiprocessor architecture, although the examples and programs have a POSIX focus. In fact, many of these concepts have existed in the literature and in a number of older operating systems going back to the late 1950s or early 1960s, when coroutines first appeared on the horizon. To say that the book is intended for serious C and Unix programmers may not be specific enough. Serious readers should have had some exposure to, and perhaps some understanding of, the issues related to synchronization and scheduling, such as mutual exclusion, signals, deadlocks, critical regions, forks, and joins. This would make the book easier to read and the examples easier to understand.