Customer Reviews

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

5 star:		(6)
4 star:		(3)
3 star:		(4)
2 star:		(1)
1 star:		(0)

 

 

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.

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.

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).

The short code snippets are horrible. If the author wants to save money and space by using code snippets, it should be checked and checked again for accuracy. There are numerous errors in the code. For example, on page 80, there is an example of condition variable usage. However, there are no function prototypes! This is just one of numerous obvious ommissions. Trust me, there are non-obvious errors too. If you're looking for an overview, this will do you fine. However, if you're looking for some decent code examples to look at, I'd suggest Butenhof's book instead.

Multi-threaded programming is difficult enough, why make it harder for yourself?

As usual, O'Reilly have produced an excellent reference book. In a few respects, this book is preferable to Scott Norton's "Thread Time" - it has better examples, for one.

But this book is not as detailed or complete as Norton, so I don't recommend it as the best choice on the subject.

With all the sophisticated tools available today such as OpenMP, this book may seem quaint. However, before grasping at concepts or just using tools without any understanding or their makeup it would be wise to add this to your learning curve.

This book gives a good basic understanding of Pthreads. Of course, you will later have to apply it to the real world but as a learning tool, this is pretty darn good. The website or path on the site has changed since publication; but the examples are still there. Because I am using AIX, it does take a little time to convert from a gcc format to an AIX format. Then a little more time to apply AIX specific advantages.

As you go from the front of the book to the end the samples are added to and new concepts become available. There are plenty of diagrams for the visual learner. I personally found the signal handling of great use.

Any way this book is not the end-all, be-all, of threads but it sure cleared many concepts up for me.

1. Why Pthreads
2. Designing threaded programs
3. Synchronizing Pthreads
4. Managing Pthreads
5. Pthreads and UNIX
6. Practical Considerations

Using OpenMP: Portable Shared Memory Parallel Programming (Scientific and Engineering Computation)

I found it too be an excellent overview. Its treatment of the issues associated with threads and signals I think was especially useful. My only complaint is with the Quick Reference in Appendix C. The reference provides no description of possible function call errors. While I admit the errors are dependant on the particular Pthreads implementation, however there are a core number of errors that would be common throughout all, or at least most, implementations. The point is if you are to do any actual programming, which I presume is the reason for a reference of function calls, you need to know what return values to expect. Providing no reference would have been better then providing a useless one.

This book does a nice job for describing the pthread API. When I have read this book, my multithread programming experience was mainly with Win32 threads and reading this book was my first exposure to the condition synchronization objects. With the help of this book, it has been a breeze to learn how to use conditions. What is missing from this book written 10 years ago, which is also missing in all multithread books that I have read of that era, is coverage on issues with parallel processing. If all you have to do with threads is to launch a background job while keeping UI responsive or asynchronous I/O on a single core processor, you will be fine with this book.

However, if you try to crunch an array of data with multiple threads each processing their own chunk of the array, you could fall into cache line alignment problems even if your threads does not access the same memory locations. Those problems are platform dependant. I have written such a program that was working wonderfully well with a Sparc station and a PowerPC based station but once ported to a x86 architecture, the program was actually becoming slower than the single thread version. It is very hard to get it right. You have to be careful about the array alignment in memory and where the boundaries of the chunks of data that you assign to threads are. What will happen if 2 threads located on 2 different processors access to the same cache line is that one processor will have to flush that cache line back to the main memory and the other processor will have to fetch the values back from the main memory to its cache. The overhead of this is so huge that processing the array from a single thread could be faster.

I still have to find a book that addresses these problems. I expect it to come soon with dual and quad core processors becoming mainstream but this is not this book.

Includes everything you would want to know about programming the Pthreads model and the tools it provides. Good running examples and library references throughout the book.

This book is an awesome book for learning pthread programming. All the concepts are explained
very nicely and it also explains the tadeoffs between processes/user level thread/kernel level thread.