This book assumes the reader has some knowledge of threading already and attempts to provide that elusive next level of information that people want after learning the mechanics of a particular threading API. That is - how best to write code that scales well, that works reliably etc.
The first half of the book is general information about that next step, the second half of the book is mostly a collection of algorithms and how their serial equivalents can be converted to make use of multiple processors/cores, together with some information about how successful the conversion is.
The code examples are mostly C, but with the odd snippet of C++ where required by the threading API being used at the time. The threading APIs used are Intel TBB, OpenMP, PThreads and Windows threads. Some examples are presented using more than one API.
All in all, this book sounds promising. However, having just read it, it really didn't work for me. You know when you are asked a question by another developer who you assume knows his/her stuff, so you answer the question correctly but without giving all of the detail that you would give to somebody more junior (as you assume the person asking the question will already know those bits of detail)? You then see the glazed look in the person's eyes, realise they actually needed the detail, so you explain again but with all the extra detail added this time. Well, to me, this book felt like that - as if it was a brain-dump that is correct, but not necessarily in enough detail to satisfy the needs of the reader. To feel definitive it needs the fuzziness removed, the conversational feel removed, and more detail added. It might become drier as a result, but I think it would be more useful.
As mentioned above, the book uses four different APIs, but doesn't provide enough information on any of them for somebody who doesn't already know them (thankfully, I do) - it certainly doesn't attempt to teach any of them. It presents examples in C (and sometimes C++), but that are not all complete (missing #includes, missing supporting functions etc), or that will build on a slack C compiler but not on a stricter one (a C++ compiler will not build some of this code as C++, mainly due to missing return values - call me fussy, but I expect newly written C to build as C++). Code examples where presented using more than one API contain little inconsistencies that break the feeling of comparing like with like. Coding standards vary between examples, making typing the examples in a tad annoying as you have to switch mentally between naming conventions.
The section on algorithms really should have been the golden nugget in this book. Indeed, the book will remain on my shelf for me to use that section as a memory aid. However, the presentation of that section, like the first half of the book, is too fuzzy and rambling. So, I'll use it to remind myself of the various algorithms, but probably then go elsewhere to find a definitive description that I can re-implement myself, possibly using this book for some suggestions.
So, a book that showed a lot of promise, but that just didn't live up to expectations. It's not a tutorial on any of the APIs (it doesn't claim to be), but it doesn't feel definitive on the algorithms either. For people with either no multi-threading experience, or people with significant multi-threading experience, I suspect this isn't the book for you. If you're in the middle, with some experience but not a huge amount, then you might find it useful.