(Larger Image)
|
Concurrent Programming in Java(TM): Design Principles and Pattern (2nd Edition)
by Doug Lea
Product Group: Book
Publisher: Prentice Hall (1999-11-04)
ISBN: 0201310090
EAN: 9780201310092
UPC: 785342310092
Dewey Decimal #: 005.2752
Binding/Media: Paperback - 432 pages
Edition: 2
SKU: 09082009-0133
Condition: New
Comments: 0201310090 New, never read, may have minor wear on cover.
|
Editorial Reviews
|
Product Description
In this second edition, you will find thoroughly updated coverage of the Java(tm) 2 platform and new or expanded coverage of: * Memory model * Cancellation * Portable parallel programming * Utility classes for concurrency control The Java platform provides a broad and powerful set of APIs, tools, and technologies. One of its most powerful capabilities is the built-in support for threads. This makes concurrent programming an attractive yet challenging option for programmers using the Java programming language. This book shows readers how to use the Java platform's threading model more precisely by helping them to understand the patterns and tradeoffs associated with concurrent programming. You will learn how to initiate, control, and coordinate concurrent activities using the class java.lang.Thread, the keywords synchronized and volatile, and the methods wait, notify, and notifyAll. In addition, you will find detailed coverage of all aspects of concurrent programming, including such topics as confinement and synchronization, deadlocks and conflicts, state-dependent action control, asynchronous message passing and control flow, coordinated interaction, and structuring web-based and computational services. The book targets intermediate to advanced programmers interested in mastering the complexities of concurrent programming. Taking a design pattern approach, the book offers standard design techniques for creating and implementing components that solve common concurrent programming challenges. The numerous code examples throughout help clarify the subtleties of the concurrent programming concepts discussed.
|
Amazon.com Review
Concurrent Programming in Java, 2nd Edition surveys a wide field of research in parallelism and concurrency and shows how to do more with multithreading in Java with dozens of patterns and design tips. Written for the advanced Java developer, this book offers a comprehensive tour of leading-edge thinking about parallel coding processes. Within the dozens of techniques and tips offered here, this book accomplishes at least two goals. First, it shows how concurrency is implemented by default within Java, with material on how built-in features (like the synchronized keyword and its memory model) can be expected to perform when dealing with multiple threads. Naturally, Java threads themselves are also covered, including priorities, scheduling, and the like. Much of this book looks at ways to improve performance of concurrent code beyond the simple default strategies. After defining criteria for measuring concurrent code (such as safety and "liveness," a measure of running live threads effectively), the book presents dozens of techniques for letting threads work together safely. For the working Java programmer, coverage of patterns that have been implemented in the downloadable java.concurrency package will be the most immediately useful. (Within this nearly encyclopedic survey, short code snippets are used for every pattern and concept.) Though theoretical at times, this book offers plenty of ideas and sample code to get you started thinking of ways to improve multithreaded code. Impressively comprehensive, Concurrent Programming in Java offers a veritable bible of techniques for doing two things at once with threads in Java. It's a worthwhile guide to the state-of-the-art strategies for improving the performance of your Java threads. --Richard Dragan Topics covered: Threads and concurrency in Java, design considerations (safety, liveness, and performance), Before/After Patterns, layering, adapters, immutability and synchronization, deadlock, resource ordering, the Java Memory Model and concurrency, using the java.concurrency package, confinement, refactoring for concurrency, mutexes, read-write locks, recovering from failure, notifications, semaphores, latches, exchanges, transactions, one-way messages, worker threads, polling and event-driven I/O, parallelism techniques (fork/join, computation trees, and barriers), Communicating Sequential Processes (CSP).
|
Customer Reviews
|
Very Good
Rating  (5)
Date: 2009-02-07
0 out of 5 customers found this reveiw helpful
I don't know about this book but having him as a teacher is pretty weird. I'm assuming his book style is the same as teaching, and that is pretty good, he helps you and knows everything about java seeing how he made some of java. Very bright.
|
|
Too Theoretical
Rating  (3)
Date: 2007-10-23
2 out of 3 customers found this reveiw helpful
The book contains a lot of concurrent and parallel programming theories, but the organization of the contents is not well formed, such that the reading and understanding of the book are hard. The examples giving in the book are not very helpful either.
Overall, the book seems to target for academic researchers rather than developers. Highly recommend "Java Concurrency In Practice" which is much more practical and easier understood by Brian Goetz
|
|
5 for knowledge; 0 for the writing -> 2.5 -> 2
Rating  (2)
Date: 2006-04-19
9 out of 13 customers found this reveiw helpful
Sure he knows his stuff but doesn't have a clue on how to write. This is appallingly poorly written. It is one of the most ridiculously disorganized collections of academic 'verbage' (verbiage subsumes garbage) I have ever read. It's almost useless as a reference: its very non-linear (say non-deterministic almost) in concept elucidation (perhaps he's taken the notion of multithreading too much to heart and tried multi-threaded writing???). It's useless as a book to learn from- since learning by example is not just a way to learn, but the only way to learn (Einstein) and this book largely disavows examples.
What it needs is another edition with a ghost writer. Seriously it's not good. Try Paul Hyde for a good intro to threads.
While those at guru-ish level may love this book, those of us for whom threads represent a means to an end, not an end in and of themselves, would probably want to throw this book in frustration of the author's inability to structure a coherent sentence with a clear point. This meanders on like great uncle herb's war stories and is equally will sapping.
Avoid if you can or check it out when you reach guru-ness. It's a good cure for insomnia though.
|
|
If you want to program concurency in Java you need this book
Rating (3)
Date: 2006-01-16
0 out of 4 customers found this reveiw helpful
This is a kind of book you'll need to start developing concurrent systems in Java. It shows details of what should be done to safely handle patterns for concurrent programs.
I beleive this book is a must for every developer who want to start learning concurrency design priciples for Java.
|
|
Great Threaded Programming Information for More than Java
Rating (5)
Date: 2006-01-09
1 out of 1 customers found this reveiw helpful
This is the best book I have ever read on threading, and certainly applies well to other languages naturally (especially languages with a modern and mature thread library like Mono/.NET). Unlike other reviewers here, I encourage so-called "beginners" to read this book. He has plenty of examples so you will not get lost, and this *is* the right way to do things, so start with this one.
|
|
|
|
|