- Paperback: 339 pages
- Publisher: Addison-Wesley Pub (Sd) (November 1996)
- Language: English
- ISBN-10: 0201695812
- ISBN-13: 978-0201695816
- Product Dimensions: 23.1 x 18.8 x 1.8 cm
- Shipping Weight: 567 g
- Average Customer Review: 4.0 out of 5 stars See all reviews (26 customer reviews)
- Amazon Bestsellers Rank: #1,176,457 in Books (See Top 100 in Books)
- See Complete Table of Contents
|
||||||||||||||||||
|
||||||||||||||||||
|
||||||||||||||||||
| ||||||||||||||||||
|
There is a newer edition of this item:
|
Product Details |
Product Description
From Amazon
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). --This text refers to an alternate Paperback edition.
Book Description
This text treats Java as a software engineering language rather than a means of developing simple applets. It aims to enable programmers to find out more about how to use concurrency in the design of classes, applets and applications to create multi-threaded applications. Features of the book include integrated surveys and tutorials on concurrency and Java programming constructs, and reusable components and micro-architectures solving common software construction problems.
Tag this product(What's this?)Think of a tag as a keyword or label you consider is strongly related to this product.
Tags will help all customers organize and find favorite items. |
What Other Items Do Customers Buy After Viewing This Item?
Customer Reviews
|
Share your thoughts with other customers:
|
||||||||||||||||||||||
|
Most helpful customer reviews
3 of 3 people found the following review helpful
5.0 out of 5 stars
Everything you need to know about concurrency in Java,
By Bob Carpenter (New York, NY) - See all my reviews
This review is from: Concurrent Programming in Java™: Design Principles and Pattern (Paperback)
Concurrent programming is fraught with peril. It's much more complex than sequential programming in every meaningful way from specification to unit testing. But if you want to do it right, meaning balancing liveness with safety for efficient and robust multi-threaded applications, you need Doug Lea's "Concurrent Programming in Java". Especially if you need to design an extensible framework with concurrency; well-known examples of such frameworks incluce Swing, most of java.net, and just about every aspect of J2EE.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.
1.0 out of 5 stars
"This is Phylosophy of concurrency".,
By T.Murayama (Tokyo,Japan) - See all my reviews
This review is from: Concurrent Programming in Java™: Design Principles and Pattern (Paperback)
This is not "concurrent programming".This is only "philosophy of concurrency".I think so too.
5.0 out of 5 stars
Excellent, Deep & Clear,
By Sollie (USA) - See all my reviews
This review is from: Concurrent Programming in Java™: Design Principles and Pattern (Paperback)
Doug Lea does an excellent work.On the one hand, he does much more than cover the API. He teaches you to *think* & understand multithreades. Example: he doesn't just state the java API won't let you modify a datastructure while iterating on it. He goes further to explain *how* java prevents this, and then details several methods to work around it. This particular example has greatly helped me with a project I'm on. On the other hand, I found the explanations clear and easy to follow. Great book...
Share your thoughts with other customers: Create your own review
Want to see more reviews on this item?
|
Most recent customer reviews |
Listmania!
|
|
Look for similar items by category
- Books > Computers & Internet > Computer Science > Software Engineering > Design Tools & Techniques
- Books > Computers & Internet > Databases > Distributed Databases
- Books > Computers & Internet > Hardware > Parallel Processing Computers
- Books > Computers & Internet > Programming > Java
- Books > Computers & Internet > Programming > Languages & Tools
- Books > Computers & Internet > Software
- Books > Professional & Technical > Professional Science > Mathematics
Look for similar items by subject
Feedback
Would you like to update product info or give feedback on images?
