- Paperback: 528 pages
- Publisher: Manning Publications; 1 edition (February 28, 2012)
- Language: English
- ISBN-10: 1933988770
- ISBN-13: 978-1933988771
- Product Dimensions: 7.4 x 1.1 x 9.2 inches
- Shipping Weight: 2 pounds (View shipping rates and policies)
- Average Customer Review: 43 customer reviews
- Amazon Best Sellers Rank: #219,521 in Books (See Top 100 in Books)
Enter your mobile number or email address below and we'll send you a link to download the free Kindle App. Then you can start reading Kindle books on your smartphone, tablet, or computer - no Kindle device required.
To get the free app, enter your mobile phone number.
C++ Concurrency in Action: Practical Multithreading 1st Edition
Use the Amazon App to scan ISBNs and compare prices.
This item, sold by Amazon.com, is currently reserved exclusively for Prime members.
- Unlimited Free Two-Day Shipping
- Instant streaming of over 40,000 movies and TV episodes
- A Kindle book to borrow for free each month - with no due dates
- Over a million songs and hundreds of playlists
Also available to Amazon Students. Check for eligibility
There is a newer edition of this item:
Customers who bought this item also bought
Customers who viewed this item also viewed
What other items do customers buy after viewing this item?
About the Author
Anthony Williams is a UK-based developer and consultant with many years experience in C++. He has been an active member of the BSI C++ Standards Panel since 2001, and is author or coauthor of many of the C++ Standards Committee papers that led up to the inclusion of the thread library in the new C++ Standard, known as C++11 or C++0x. He has been the maintainer of the Boost Thread library since 2006, and is the developer of the just::thread implementation of the C++11 thread library from Just Software Solutions Ltd. Anthony lives in the far west of Cornwall, England.
Top customer reviews
There was a problem filtering reviews right now. Please try again later.
It is acceptable in that it does contain a *lot* of information, and the author clearly knows what he's talking about. I'm several chapters in and I feel that I am learning a lot about concurrency...both the issues, and how to address them using C++ 11.0 (and presumably eventually using Boost). So this is good.
Unfortunately he has a rather rambling style that does not engage the reader (or at least me). Although the chapters seem to provide a reasonable global organization for the information, each individual chapter is presented almost as a hodgepodge of ideas and examples with little flow. I find myself saying "is this critically important, or is this a rare exception he's pointing out for the sake of covering every possibility?"
In places, even individual paragraphs ramble and have a hard time getting to their point. For instance, he explains the rather simple concept of deadlock with a drawn out metaphor about two children wanting to play with a drum, but needing both the drum and the stick...and if one child has both, they can play merrily on their drum while the other looks on....but if one of them finds the drum and the other the stick, then neither can play unless *yawn* somebody gives in or...and it just goes on. I have nothing against metaphor; a Wikipedia site summarized the concept nicely by pointing out (in about two sentences) an old Kansas law that required two trains who meet one another head on to stop and neither may proceed until the other has passed. Nice. Succinct. Even hilarious. I cannot say the same of Williams.
As far as using it for a text, the book has no problems to assign (or for a reader to do in order to engage with the material), and I can't see any undergrad sticking with his writing long enough to read even a section of it. If I teach a class on this material, it will be from my own notes, examples, and problems.
So although you can learn from this book, I feel like there is much more the author could have done to help the reader. There's a lot of wading through bad style and sifting through poor organization that you must do on your own...so I find it slow going. Not outright bad. Just tedious.
This is for the Kindle version, I have no idea what the print version might look like.
Let me start by saying the book is great, and certainly worth buying if you're interested in the subject. C++11 has been around for a while now, and Boost threads for a lot longer, yet there isn't a ton of quality literature out there that covers quite the same subjects in the same stretch this book does.
The TL;DR version of my review is this: If you're interested in concurrency and/or std::thread, are somewhere around intermediate level as a programmer and familiar with C++, this is a fantastic book. The Kindle version is somewhat weak in terms of listings/images but thankfully the way the book is written that's not showstopping.
The longer version:
I see a few people resenting the author's use of metaphor and the writing style. To each their own, of course, but personally I enjoyed reading most chapters and didn't mind the tone and the metaphors most of the time, though some do feel belabored if you're even remotely familiar with the concepts already.
It's relatively packed with exposition and not too much code by most standards, but what code there is reads well, is concise in style without being cryptic, and the solutions are all both applicable and do a good job of exemplifying the case. I felt the balance worked out.
It's the kind of book you can very easily read without a computer anywhere nearby with just the occasional glance at the listings, which is how I happened to read it.
This brings me to the weakest point of the Kindle edition, the conversion is so-so.
Most listings are relatively low res fuzzy images. Not so low res you won't be able to read them once you select-zoom them, but enough to be annoying to read even with 20/20 eyesight on e-ink, and still not looking too hot on a backlit tablet.
Some of the listings, possibly to help with the layout, are split over multiple images, which means they often lay out poorly even when you have the book up on a tablet, let alone on an e-reader.
The index is also very sparse and poor, with some chapters being as big as they are if you touch the screen in the wrong place (and click a link to a previous chapter) you might be in for a lot of swiping to get back to where you were, no sub-indices.
Is it major? I don't believe so, the book is worth every penny regardless, but it could have been a much smoother read, and it sticks out when most of the rest of the editing and authoring work are up to higher standards.
As for the contents it ranges from good to excellent.
Williams goes over the basics of dealing with threads and ties them in nicely with the Standard Library facilities.
The basics cover ground from simple spawn/join all the way to managed thread pools, going through std::atomic (which is an tough subject to write about in an introductory manner) and I thought he never failed to provide just enough to make sense of things completely without becoming lost or overwhelming.
The focus is on Standard Library facilities, but the information will all apply to mostly any threading library you could care to use on a desktop or server CPU. He doesn't obsess over features, and he sticks to facts and techniques with no expression of opinions; focuses on actual concurrency problems and solutions and just happens to use std::thread, std::atomic and accessories to present the solutions. It's done well, it works, I got a lot out of the exposition and examples being laid out the way they are.
What I have to admit to being a bit disappointed with is the testing and debugging section. It's extremely brief and it feels like he tried, then found the subject too hard to lay out to the same standards he did the rest, and then just gave up on to leave a handful of pages in.
The rest of the work in the book outlines both obvious and subtle pitfalls of various models and operations well, so I don't feel let down as that was worthwhile my time and good enough to know what to look for if your code sets the farm on fire, but since he did put a chapter in there about testing I thought he should have done a better job of it or simply avoid it.
Half the book is appendix items, which is a bit weird, but over half of those are going to be worth it for a lot of people.
The one dedicated to C++11 features relevant to the book is well scoped and useful if you haven't been using it much yet, and there's a one for a more extensive and code complete implementation of an ATM example he uses in the book (which I didn't read to be honest). One on other threading libraries is superfluous but small anyway.
There's also a rather odd appendix that goes into excruciating detail over some stdlib interfaces that I didn't care much for, but at that point I had got more than my money worth out of the book so I can't complain, and maybe there is a readership that is interested in every detail of every method of every object std::chrono has to offer :)
Most recent customer reviews
In the second edition we expect:
1) a greater number of solved algorithms, focused...Read more