C++ Concurrency in Action: Practical Multithreading 1st Edition

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

There are quite a lot of books covering C++ multithreading programming books which ranges from posix thread programming to Win32 programming. However, there are few books that cover the concurrency and thread programming as in C++11 standard. In addition, the author himself is a contributor to this part of C++11 standard.That said, it doesn't qualify the book as best automatically. The real reason for that I think is the examples are very clearly explained in the book and the framework used in the book seem to be very adaptable to your real-world project easily. In that sense, it is really a practical multithreading programming book.One caveat though: This book would not teach C++ programming and not even C++11 even if you have some fine grasp of C++. I recommend you get hold of The C++ Programming Language (B. Stroustrup, 4th Edition) or C++ Primer (S. Lippman etc., 5th Edition). The book itself may need some clarification in some place, for example, it should really talk about using -lpthread for linking since it discusses various compilers for C++11 anyway. However, given the aforementioned need of a C++11 text to accompany it, I would still rank this book a 5-star as those minor problems could be figured out easily given books above or you can easily find answers from stackoverflow.com etc.

Still on my way through reading this, but as someone who uses C++ at above intermediate (still not accepting to call myself an expert) this book holds a lot of valuable information on C++11 and the threading capabilities that come with it. I had a basic understanding of mutex's, deadlock issues etc going into the first chapters. I feel that having read halfway through the book that I could use the threading api's effectively whereas so that is a win.However, the information presented is done so a bit dry for my tastes. Because of this it has been a great book for my late night reading because I still learn a few concepts and then start finding myself getting drowsy and ready for sleep. It may need less rambling as one reviewer had mentioned. I did agree some paragraphs actually made me re-read because it didn't flow as smoothly, however the writing isn't necessarily bad. I think the author is trying to give a LOT of information and sometimes it bounces around a bit much.So far I have been able to get what I wanted to get out of the book.

This book is very well crafted. However, I would suggest to buy the updated version.

As of Aug 2012 when I wrote this, most c++ compilers do not support threads including the GNU C++11 compiler 4.7. I finally got it to work but compiled with both the pthreads library and installed boost libs, probably only one of those was needed, I don't know which as I was too lazy to figure it out. Seems to be a little cheating going on with the compiler as C++11 threads are invoked differently than either of these, I'm guess that this compiler just uses a wrapper around whichever of those components are needed.I had worked with pThreads several times over the last few years, only got though the first 1/3 of the book, but I can already tell you it was worth the investment if you are planning on doing any work with threads in C++. Thumbing though into later chapters it looks like a lot more useful stuff using more complex semaphores and threads.From my review of the first 1/3rd, I'd say it's a definite keeper.