Pthreads Programming: A POSIX Standard for Better Multiprocessing (O'Reilly Nutshell) (Paperback)

~ (Author), Dick Buttlar (Author), Jacqueline Proulx Farrell (Author)

Editorial Reviews

Product Description

POSIX threads, or pthreads, allow multiple tasks to run concurrently within the same program. They can share a single CPU as processes do, or take advantage of multiple CPUs when available. In either case, they provide a clean way to divide the tasks of a program while sharing data. This book thoroughly covers the POSIX threads standard, which is supported by the Distributed Computer Environment (DCE), as well as Solaris, OSF/1, AIX, and several other UNIX-based operating systems. In this book you will learn not only what the pthread calls are, but when it is a good idea to use threads and how to make them efficient (which is the whole reason for using threads in the first place). The authors delves into performance issues, comparing threads to processes, contrasting kernel threads to user threads, and showing how to measure speed. He also clearly describes all the advanced features and how threads interact with the rest of the UNIX system.

From the Publisher

Computers are just as busy as the rest of us nowadays. They have lots of tasks to do at once, and need some cleverness to get them all done at the same time. That's why threads are seen more and more often as a new model for programming. Threads have been available for some time. The Mach operating system, the Distributed Computer Environment (DCE), and Windows NT all feature threads. One advantage of most UNIX implementations, as well as DCE, is that they conform to a recently ratified POSIX standard (originally 1003.4a, now 1003.1c), which allows your programs to be portable between them. POSIX threads are commonly known as pthreads, after the word that starts all the names of the function calls. The standard is supported by Solaris, OSF/1, AIX, and several other UNIX-based operating systems. The idea behind threads programming is to have multiple tasks running concurrently within the same program. They can share a single CPU as processes do, or take advantage of multiple CPUs when available. In either case, they provide a clean way to divide the tasks of a program while sharing data. A window interface can read input on dozens of different buttons, each responsible for a separate task. A network server has to accept simultaneous calls from many clients, providing each with reasonable response time. A multiprocessor runs a number-crunching program on several CPUs at once, combining the results when all are done. All these kinds of applications can benefit from threads. In this book you will learn not only what the pthread calls are, but when it is a good idea to use threads and how to make them efficient (which is the whole reason for using threads in the first place). The authors delves into performance issues, comparing threads to processes, contrasting kernel threads to user threads, and showing how to measure speed. He also describes in a simple, clear manner what all the advanced features are for, and how threads interact with the rest of the UNIX system. Topics include: Basic design techniques Mutexes, conditions, and specialized synchronization techniques Scheduling, priorities, and other real-time issues Cancellation UNIX libraries and re-entrant routines Signals Debugging tips Measuring performance Special considerations for the Distributed Computing Environment (DCE)

See all Editorial Reviews

Product Details

• Paperback: 286 pages
• Publisher: O'Reilly Media; 1 edition (September 1, 1996)
• Language: English
• ISBN-10: 1565921151
• ISBN-13: 978-1565921153
• Product Dimensions: 9.1 x 7 x 0.8 inches
• Shipping Weight: 1.1 pounds (View shipping rates and policies)
• Average Customer Review: 3.7 out of 5 stars  See all reviews (11 customer reviews)
• Amazon.com Sales Rank: #273,577 in Books (See Bestsellers in Books)

  Popular in these categories: (What's this?)

  #28 in	Books > Computers & Internet > Hardware > Parallel Processing Computers
  #43 in	Books > Computers & Internet > Databases > Distributed Databases

Customer Reviews

Most Helpful Customer Reviews

21 of 22 people found the following review helpful:

3.0 out of 5 stars Okay for concepts, but no help in coding, June 23, 1999

By	From_Plano_TX "a_customer_from_plano" (Plano, TX USA) - See all my reviews

The strength of this book is it's brevity: 233 pp of text plus appendices. But the code samples are incomplete (fragments). You'll be able to get an idea of how pthreads work and the methods available, but you'll have a very hard time if you need to actually write code. There is an error on p.126. If you want to write code, get "Programming with POSIX Threads" by David Butenhof. It has complete code examples and is not that much longer: 305 pp of text plus appendices. But I did find this Nichols book helpful when I was curious about pthreads. I commend O'Reilly for the nice illustrations in this book -- above average. They helped convey concepts.

13 of 14 people found the following review helpful:

3.0 out of 5 stars Good Pthreads book but I like other available books better, January 4, 1999

By A Customer

Of the 4 I've read on the topic, this is a good book but my personal preference (based on how the information was presented, the relevance of coding examples, etc.) is for the Butenhof Pthreads book (excellent) or the Lewis, et. al. Multithreaded Programming book (also very good).

11 of 12 people found the following review helpful:

4.0 out of 5 stars I think it provides a good overview, September 22, 2000

By	Dan Crevier (Bellevue, WA United States) - See all my reviews (REAL NAME)

I agree with the other reviews that it's not the ultimate authority on pthreads, but I think it provides a great overview from a very practical standpoint. It has lots of good discussions on when to use threads, general design priniciples of using threads, problems you will likely encounter, and discussions of performance. It also has some good examples, including an example of how to turn some non-thread-safe linked list code into thread-safe code. I really like that its brief and doesn't go into too many details -- you can read it from cover to cover. If you want more details, you will want to refer to one of the other books that the other reviewers have mentioned.