• RRP: £44.99
  • You Save: £8.97 (20%)
FREE Delivery in the UK.
Only 2 left in stock (more on the way).
Dispatched from and sold by Amazon.
Gift-wrap available.
Quantity:1
C++ Concurrency in Action... has been added to your Basket
+ £2.80 UK delivery
Used: Like New | Details
Condition: Used: Like New
Comment: 100% Money Back Guarantee. Brand New, Perfect Condition, FAST SHIPPING TO UK 4-14 business days, all other destinations please allow 8-18 business days for delivery. Over 1,000,000 customers served.
Trade in your item
Get a £14.98
Gift Card.
Have one to sell?
Flip to back Flip to front
Listen Playing... Paused   You're listening to a sample of the Audible audio edition.
Learn more
See all 2 images

C++ Concurrency in Action: Practical Multithreading Paperback – 15 Mar 2012


See all formats and editions Hide other formats and editions
Amazon Price New from Used from
Paperback
"Please retry"
£36.02
£25.06 £25.21
£36.02 FREE Delivery in the UK. Only 2 left in stock (more on the way). Dispatched from and sold by Amazon. Gift-wrap available.

Frequently Bought Together

C++ Concurrency in Action: Practical Multithreading + Effective Modern C++: 42 Specific Ways to Improve Your Use of C++11 and C++14
Price For Both: £58.80

Buy the selected items together


Trade In this Item for up to £14.98
Trade in C++ Concurrency in Action: Practical Multithreading for an Amazon Gift Card of up to £14.98, which you can then spend on millions of items across the site. Trade-in values may vary (terms apply). Learn more

Product details

  • Paperback: 528 pages
  • Publisher: Manning Publications; 1 edition (15 Mar. 2012)
  • Language: English
  • ISBN-10: 1933988770
  • ISBN-13: 978-1933988771
  • Product Dimensions: 18.7 x 2.7 x 23.5 cm
  • Average Customer Review: 4.7 out of 5 stars  See all reviews (3 customer reviews)
  • Amazon Bestsellers Rank: 66,607 in Books (See Top 100 in Books)

More About the Author

Discover books, learn about writers, and more.

Product Description

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.


Inside This Book (Learn More)
Browse Sample Pages
Front Cover | Copyright | Table of Contents | Excerpt | Index | Back Cover
Search inside this book:

What Other Items Do Customers Buy After Viewing This Item?

Customer Reviews

4.7 out of 5 stars
5 star
2
4 star
1
3 star
0
2 star
0
1 star
0
See all 3 customer reviews
Share your thoughts with other customers

Most Helpful Customer Reviews

3 of 3 people found the following review helpful By Pattabi Raman on 8 Mar. 2013
Format: Paperback Verified Purchase
It is an understandable, readable book and nice flow of text from one chapter to another. Tough the subject (concurrency/multi-threading) is complex; the author has provided a systematic path.
Comment Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again
9 of 11 people found the following review helpful By J. Bond VINE VOICE on 23 May 2012
Format: Paperback
This is an excellent introduction to using the standard template library threading functionality, covering all the details, foils and benefits of doing things right.

The text however could be a little more concise in places, and the examples given are (obviously) only for STD C++11 compilers - which are available for Linux/Unix without a hitch, but currently Microsoft only have a smattering of features supported in their compiler. This is not the books fault, the fault of the book is not to point this out, not to help the reader perhaps find a suitable runtime environment in which to run the examples in the books.

Is gcc -std=c++0x sufficient?.... Will Visual Studio 2012 eventually have more support for the STD threading?... I think the book should have introduced the reader to this, I know its nit picking, but the author of the book is also the author of the boost threading library, boost are notorious for not really documenting their work, leaving the window open for books such as this very one to document how to do things. The new std threading standard is, for the most part, based on the boost threading model and the author make hooting mention of this, but does not start off with the most basic level - where and what to compile the examples with.

Don't let this detract from the book itself, its content is very good, just doubly so if you work out how/where to compile the examples given.
4 Comments Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again
0 of 1 people found the following review helpful By Marian Krivos on 6 Dec. 2014
Format: Paperback Verified Purchase
1. Universal and deep introduction into concurrency.
2. Complete C++ 11 threading model from one of the standard creators.
3. Very well written book.
Comment Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again

Most Helpful Customer Reviews on Amazon.com (beta)

Amazon.com: 0 reviews
79 of 81 people found the following review helpful
A useful text on multithreading in C++ 8 Mar. 2012
By Alexandros Gezerlis - Published on Amazon.com
Format: Paperback
"C++ Concurrency In Action: Practical Multithreading" by Anthony Williams is the first book to come out on multithreading and concurrency in the new C++. Williams is currently the primary developer and maintainer of the Boost.Thread library, a writer of many proposals for the C++11 thread library, and has for a while now provided (for a price) its first complete implementation (just::thread).

The Good: at long last C++ is thread-aware and this book shows the reader how to harness this newfound power. Williams starts out by introducing a number of thread-related concepts, like mutexes, condition variables, futures, promises, and atomics. This is an example-based book, so every new topic is fleshed out in code. Having introduced these concepts, the author goes on to apply them by designing lock-based concurrent data structures (a stack, a queue, a lookup table, and a linked list). Williams also shows how to use atomic operations to create lock-free stacks and queues. The book then examines more involved topics like thread pools (for which C++17 will probably have built-in support, though Williams doesn't venture a guess) and is rounded out by a welcome overview of how to identify deadlocks, livelocks, data races, and so on. Given the thematic breakup of the chapters, as well as the wealth of the material collected in the Appendices, this book will come in very handy as a reference. More specifically, Appendix B has a nice comparison of the new C++ multithreading facilities with Java threads, POSIX threads, and the Boost Thread library. Even better is Appendix D, a very useful 120-page reference of the C++11 thread library, which is more usable in digital form (as part of the ebook or the online version of the just::thread documentation). This volume is not a tutorial on C++11, but Williams uses a number of its facilities repeatedly (e.g. deleted and lambda functions, as well as auto, rvalue references, move constructors, and variadic templates) and then gathers them all up in Appendix A, along with other features (like constexpr functions and std::tuple). Given the current scarcity of decent material on C++11, the repeated use of new constructs means that Williams' book can also function as a practical introduction of sorts to the new language standard. From a more pragmatic perspective, it's worth pointing out that you can find the complete source code for the book on the publisher's website. Importantly, everyone who buys a paper copy of the book may also download a free e-book version. As I've written before, it is to be hoped that other publishers will follow Manning's example.

The Bad: parts of the book feel more like a reference than a tutorial. In the early chapters, when Williams is introducing things like mutexes, futures, etc from the C++ thread library (along with a couple of boost constructs) it feels like he's faced with a number of C++ entities for which he has to provide a raison d'etre, so he goes over them one by one. Thus, from the get-go "C++ Concurrency In Action" seems to implicitly assume that the reader is already comfortable with conceptual questions relating to concurrency, e.g. after finishing this book a reader would not know what a semaphore is -- this should be contrasted with David Butenhof's classic "Programming with POSIX threads". In all fairness, Williams does discuss conceptual issues in chapter 8 (of 10), but what he includes there is too little too late (on a related note, section 8.3.1 on matrix multiplication is just begging for some example code, especially given the unconventional notation used in the figure). Even so, most of the multithreading material is actually explained: perhaps not always masterfully (e.g. "if your roommate occupies the bathroom for a long time, it can be frustrating if you need to use it"), but explained nonetheless. Things are different when it comes to the grasp of C++ Williams assumes of the reader: he uses std::result_of and std::make_shared hundreds of pages before explaining them, though that's still better than the case of std::mem_fn, which is simply never discussed (note that all of these are TR1-related). Ditto for std::distance. Sometimes he also borders on bad practice, in one case using no access specifier for the base class when inheriting and, in another case, showing a function defined in a friend declaration of a class -- both times without explicitly saying he's doing so. (I won't dwell on outright errors, like using Template Argument Deduction for a class template, p. 244, and then assuming that you can deduce the return type, pp. 246, 247, 249.) Yes, a "good working knowledge of C++ is assumed" by Williams, but it's worth pointing out that in "Effective C++" Scott Meyers devotes two sentences to explaining even what a default constructor is. Given the book's list price, a little more attention to detail and a few extra explanations would have been welcome.

In summary, this book suffers from pedagogical flaws, but it is a good reference. Equally important, this is the first book on the subject and it's written by a knowledgeable person so, unless someone like Hans Boehm decides to write a similar volume, Williams will probably have no serious competition. (Herb Sutter's "Effective Concurrency", if it comes out, will most likely belong to the "second book on the subject" genre.) Thus, I cannot in good conscience give this volume less than four stars.

Alex Gezerlis
20 of 22 people found the following review helpful
Full of good information, but not the best writing. 4 Aug. 2013
By Annika K. Miller - Published on Amazon.com
Format: Paperback Verified Purchase
I am a fairly experienced C++ programmer, who is pretty new to concurrency, aside from the main basic ideas. I picked up this book to expand and deepen my understanding, and to consider using it as a classroom text. Overall, I find the book acceptable, but not impressive.

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.
11 of 12 people found the following review helpful
Outstanding! 20 May 2012
By Scott Zimmerman - Published on Amazon.com
Format: Paperback Verified Purchase
I just finished reading this book--twice! The second half requires careful study to get the most out of it. This is really an OUTSTANDING piece of work. The writing is clear and all the code examples are precisely to the point. Virtually zero fluff in this entire book. You can only imagine how much work he put into designing and debugging the programs so that they are so clean. Well, I didn't notice any bugs in the code, but I didn't try to run them yet and his narrative shows that his attention to detail goes way beyond a quick code review.
Here are the things I liked most about this book: 1) it thoroughly uses C++11 features, including std::move, etc. 2) it's comphrehensive coverage of threading; and 3) it includes code and design discussion for a complete thread pool.
In my opinion there are only a few shortcomings: 1) The discussions of packaged_task, promise, spinlock, and fences/barries wasn't elaborate enough to help me really learn when/where to use these tools. Futures and async were covered thoroughly, but not these other topics. There was comment about spinlock unblocking the current thread that I didn't understand.
2) There are many places where the author/editor could have tied more narrative to the bullets in the code. That's a nifty feature of this book series, and it worked very well in this book, except that in some places it should have been done more. A couple of tricky lines of code had no comment, e.g. how the handle() function works in the message passing example. The chaining syntax is unusual and needs more explanation.
3) spinlock, and a few other topics, are not in the index.
4) It would be very helpful to see a brief example program that would report the relative performance of an analogous data structure class from the lock-based chapter vs. the lock-free chapter. This would give the reader a glimpse as to when the added complexity pays off.
I will keep this book for a long time :-)
12 of 14 people found the following review helpful
Concurrency in C++11 standard 26 April 2012
By Bas Vodde - Published on Amazon.com
Format: Paperback
I was a reviewer for an early draft of this book. At that time, the new C++ standard was still called C++0x because... of course it would be published before 2010. It didn't. The author patiently waited finishing this book until the C++ standard was finished so that it is inline with the new C++11 standard.

The book described the new C++ threading standard library and how to use it. It assumes a fairly good understanding of C++ already, it isn't the first C++ book you want to pick up :P. I felt it was pretty well written and easy to understand, though I wasn't always comfortable with the authors programming style.

The book consists of ten chapters. The first five are chapters that introduce the basic concurrency classes in the new C++ standard: Threads, mutex, promises and more. Chapter 6-8 are about designing Concurrent C++ applications and I felt it was good that the book went further than just explaining the new library constructs. The last 2 chapters are a bit more advanced topics about thread management and testing.

As said, I enjoyed the book. It was well written and I wasn't familiar with everything from the latest C++ standard yet (Appendix gives an introduction to all the changes in the C++11 standard. I'd definitively recommend this book for anyone who want to write multi-threaded applications in C++. I know of no book that does a better job at this moment. 4 out of 5 stars as the book does an exceptionally good job at what it should do, yet it wasn't a WOW-insight book.
5 of 6 people found the following review helpful
Difficult subject, rambling style, but loads to grok 16 Nov. 2014
By Monalisa and Arindam - Published on Amazon.com
Format: Paperback
It is a good book, and about the only book as of this writing that covers concurrency in C++11. However there are real flaws in the book. It is a brick and it could have been better because there are entire sets of paragraphs that could have been condensed into much more readable, tight, meaningful content. There are subjective statements casually thrown around that ultimately get to you and puncture your concentration when you're trying to make sense of a difficult subject - like the memory models (Chapter 5). In fact Chapter 5 is the single most disappointing chapter for its haphazard treatment of what is perhaps the most difficult and advanced topic in C++. Make no mistakes, you will still perhaps learn a fair bit - but for the bulk of the chapter, the takeaways could be hard to objectively list unless you're an exceptionally good and focused reader. Chapter 6 is perhaps the gem of the book - the stuff that most mainstream concurrency books touch and never quite cover as well as Anthony Williams does in this book. By all means buy this book and read it, because Effective Concurrency by Herb Sutter comes out on July 28, 2016 - that's 20 more months! But make sure you don't depend on this book solely for memory models, and make sure you have a lot of patience while reading through this. And I would likely need two more reads through the book to grok the stuff better. I was tempted to give this book 4 stars for the ground it covers but went with three because some would have given 4 under similar dilemma.
Were these reviews helpful? Let us know

Look for similar items by category


Feedback