- Paperback: 432 pages
- Publisher: Addison-Wesley Professional; 2 edition (November 4, 1999)
- Language: English
- ISBN-10: 0201310090
- ISBN-13: 978-0201310092
- Product Dimensions: 7.3 x 1.2 x 9 inches
- Shipping Weight: 1.6 pounds (View shipping rates and policies)
- Average Customer Review: 3.9 out of 5 stars See all reviews (36 customer reviews)
- Amazon Best Sellers Rank: #294,430 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.
Concurrent Programming in Java: Design Principles and Pattern, 2nd Edition 2nd Edition
Use the Amazon App to scan ISBNs and compare prices.
O'Reilly Learning Series
Featured 'Learning' Series from O'Reilly Media. See more
Frequently bought together
Customers who bought this item also bought
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).
From the Back Cover
In this second edition, you will find thoroughly updated coverage of the Javao 2 platform and new or expanded coverage of:
- Memory model
- 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.
If you are a seller for this product, would you like to suggest updates through seller support?
Top Customer Reviews
Lea provides an intense introduction at the level of an advanced undergraduate course. It's fairly academic in tone, because he takes the time to provide thorough definitions and detailed examples. As a former academic who now designs and programs for a living, this is just what I was looking for. But don't buy this book expecting a cookbook of code to cut and paste. It's much more about providing you the fundamental tools to design your own concurrent classes, applications and frameworks.
Lea presupposes the user is fluent in Java, knows a bit about concurrent programming patterns involving mutexes, semaphores, etc, and is familiar with the basic object-oriented design patterns. If you're not up to speed in these areas, the path I followed was reading the following:
* Lewis's "Threads Primer" (warning: it's C/unix-based),
* Gosling and Joy's "Java Programming Language",
* Bloch's "Effective Java", and
* Gamma et al.'s "Design Patterns".
Even if you don't buy this book, consider using Lea's concurrent.util package available from his web site. It provides solid implementations of everything from simple mutexes to concurrent read-single write wrappers for Java collections (Sun's own wrappers simply synchronize all methods, which suffers reduced liveness compared to CRSW designs). And it's both elegantly designed and thoroughly javadoc-ed.
The first edition was great, and I've just finished reading the second edition cover to cover and it has taken my understanding of concurrent design to a new level. Just be warned that this book's not for novices or hobbyists; it's for programmers who need to design the guts of concurrent systems the "right" way and then implement them in Java, especially for extensible frameworks.
Most Recent Customer Reviews
although this book was published in 1999 ,
Java Concurrency Implementation has been...Read more