EUR 46,95
  • Alle Preisangaben inkl. MwSt.
Nur noch 1 auf Lager (mehr ist unterwegs).
Verkauf und Versand durch Amazon.
Geschenkverpackung verfügbar.
Menge:1
C++ Concurrency in Action ist in Ihrem Einkaufwagen hinzugefügt worden
Ihren Artikel jetzt
eintauschen und
EUR 15,37 Gutschein erhalten.
Möchten Sie verkaufen?
Zur Rückseite klappen Zur Vorderseite klappen
Anhören Wird wiedergegeben... Angehalten   Sie hören eine Probe der Audible-Audioausgabe.
Weitere Informationen
Alle 2 Bilder anzeigen

C++ Concurrency in Action (Englisch) Taschenbuch – Februar 2012


Alle Formate und Ausgaben anzeigen Andere Formate und Ausgaben ausblenden
Amazon-Preis Neu ab Gebraucht ab
Taschenbuch
"Bitte wiederholen"
EUR 46,95
EUR 43,91 EUR 60,93
63 neu ab EUR 43,91 5 gebraucht ab EUR 60,93

Wird oft zusammen gekauft

C++ Concurrency in Action + The C++ Standard Library: A Tutorial and Reference + The C++ Programming Language
Preis für alle drei: EUR 148,85

Die ausgewählten Artikel zusammen kaufen
Jeder kann Kindle Bücher lesen — selbst ohne ein Kindle-Gerät — mit der KOSTENFREIEN Kindle App für Smartphones, Tablets und Computer.


Produktinformation

  • Taschenbuch: 528 Seiten
  • Verlag: Manning (Februar 2012)
  • Sprache: Englisch
  • ISBN-10: 1933988770
  • ISBN-13: 978-1933988771
  • Größe und/oder Gewicht: 18,7 x 2,7 x 23,5 cm
  • Durchschnittliche Kundenbewertung: 4.2 von 5 Sternen  Alle Rezensionen anzeigen (4 Kundenrezensionen)
  • Amazon Bestseller-Rang: Nr. 8.979 in Fremdsprachige Bücher (Siehe Top 100 in Fremdsprachige Bücher)

Mehr über den Autor

Entdecken Sie Bücher, lesen Sie über Autoren und mehr

Produktbeschreibungen

Über den Autor und weitere Mitwirkende

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 leading up to the inclusion of the thread library in the upcoming C++ Standard (known as 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++0x thread library from Just Software Solutions Ltd. Anthony lives in the far west of Cornwall, England.

Welche anderen Artikel kaufen Kunden, nachdem sie diesen Artikel angesehen haben?


In diesem Buch (Mehr dazu)
Ausgewählte Seiten ansehen
Buchdeckel | Copyright | Inhaltsverzeichnis | Auszug | Stichwortverzeichnis | Rückseite
Hier reinlesen und suchen:

Kundenrezensionen

4.2 von 5 Sternen
Sagen Sie Ihre Meinung zu diesem Artikel

Die hilfreichsten Kundenrezensionen

Von Gerd Hirsch am 10. November 2013
Format: Taschenbuch Verifizierter Kauf
Ohne die Infos hat man kaum eine Chance mit dem C++11 Standard nebenläufige Programme zu schreiben. Wer vorher "Java Concurrency in practice" liest, hat einen Vorteil, dort werden bestimmte Zusammenhänge besser erklärt
Kommentar War diese Rezension für Sie hilfreich? Ja Nein Feedback senden...
Vielen Dank für Ihr Feedback. Wenn diese Rezension unangemessen ist, informieren Sie uns bitte darüber.
Wir konnten Ihre Stimmabgabe leider nicht speichern. Bitte erneut versuchen
Von Bettina Baer am 20. Mai 2013
Format: Taschenbuch Verifizierter Kauf
Well written and understandable. I wasn't thrilled with the typesetting, but that might be an issue of taste. I have also found it useful as an introduction into c++ 11.
Kommentar War diese Rezension für Sie hilfreich? Ja Nein Feedback senden...
Vielen Dank für Ihr Feedback. Wenn diese Rezension unangemessen ist, informieren Sie uns bitte darüber.
Wir konnten Ihre Stimmabgabe leider nicht speichern. Bitte erneut versuchen
Von electronica am 1. September 2013
Format: Taschenbuch Verifizierter Kauf
Wer etwas tiefgreifender über Threading erfahren möchte ist hier genau richtig. Aus technologischen Aspekt sehr interessant, kann ich nur empfehlen.
Kommentar War diese Rezension für Sie hilfreich? Ja Nein Feedback senden...
Vielen Dank für Ihr Feedback. Wenn diese Rezension unangemessen ist, informieren Sie uns bitte darüber.
Wir konnten Ihre Stimmabgabe leider nicht speichern. Bitte erneut versuchen
1 von 4 Kunden fanden die folgende Rezension hilfreich Von Markus Proell am 6. Juni 2013
Format: Taschenbuch Verifizierter Kauf
I was a bit disappointed by this book. I was especially hoping for answers concerning debugging and testing concurrent code. The answer provided by the book is mainly "read your code carefully!". Since i already have a book on C++11, i don't care about these any more. Still i got some valueable information i can certainly use to improve my C++.
Kommentar War diese Rezension für Sie hilfreich? Ja Nein Feedback senden...
Vielen Dank für Ihr Feedback. Wenn diese Rezension unangemessen ist, informieren Sie uns bitte darüber.
Wir konnten Ihre Stimmabgabe leider nicht speichern. Bitte erneut versuchen

Die hilfreichsten Kundenrezensionen auf Amazon.com (beta)

Amazon.com: 25 Rezensionen
77 von 79 Kunden fanden die folgende Rezension hilfreich
A useful text on multithreading in C++ 8. März 2012
Von Alexandros Gezerlis - Veröffentlicht auf Amazon.com
Format: Taschenbuch
"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
18 von 19 Kunden fanden die folgende Rezension hilfreich
Full of good information, but not the best writing. 4. August 2013
Von Annika K. Miller - Veröffentlicht auf Amazon.com
Format: Taschenbuch Verifizierter Kauf
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 von 12 Kunden fanden die folgende Rezension hilfreich
Outstanding! 20. Mai 2012
Von Scott Zimmerman - Veröffentlicht auf Amazon.com
Format: Taschenbuch Verifizierter Kauf
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 von 14 Kunden fanden die folgende Rezension hilfreich
Concurrency in C++11 standard 26. April 2012
Von Bas Vodde - Veröffentlicht auf Amazon.com
Format: Taschenbuch
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.
4 von 4 Kunden fanden die folgende Rezension hilfreich
Difficult subject, rambling style, but loads to grok 16. November 2014
Von Monalisa and Arindam - Veröffentlicht auf Amazon.com
Format: Taschenbuch
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.
Waren diese Rezensionen hilfreich? Wir wollen von Ihnen hören.