* One of Java's most powerful capabilities is its built-in support for concurrent programming, a design technique in which multiple concurrent activities-threads take place inside a single Java program. Thread programming enables developers to design applications that are more responsive to user demands, faster, and more easily controlled. * This book offers comprehensive coverage of this vital aspect of the Java language. The book is completely up-to-date with the new thread model that is now incorporated into the most recent version of the Java Virtual Machine. All Java programmers interested in doing concurrent programming must understand these new concepts. The book approaches the topic from a design pattern point of view. It introduces and summarizes Java's concurrency support, shows readers how to initiate, control, and coordinate concurrent activities, and offers numerous recipe-like techniques for designing and implementing Java structures that solve common concurrent programming challenges. Specifically, the book presents important strategies for avoiding the inconsistencies that can crop up in multi-threaded programs, addresses the concept of "liveness"-how to ensure that all threads in use are kept active simultaneously, examines state-dependent action, and demonstrates effective methods for handling user requests in a multi-threaded environment.
 |
| ||||||||||||
Save up to 70% when you rent your textbooks on Amazon. Keep your textbook rentals for a semester and rental return shipping is free. |
Book Description
Frequently Bought Together
Editorial Reviews
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).
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
- 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.
0201310090B04062001
Product Details
Would you like to update product info or give feedback on images? |
More About the Author
Discover books, learn about writers, read author blogs, and more.
Customer Reviews
Most Helpful Customer Reviews
32 of 32 people found the following review helpful
Format:Paperback
Simply a great book on concurrent programming in Java. This book and the class library the author provides are an awesome combination. While some of the information is Java specific, this book is much more about concurrent programming in general.
The author explains the primitive concurrency mechanisms provided in Java, such as Threads and Monitors, and then quickly moves on to higher level abstractions that embody many of the patterns found in multi-threaded applications. By encapsulating these, sometimes complex, patterns in reusable classes, the author shows how to maintain the separation of concerns between the concurrent aspects of the code and the logic of the task at hand.
This book contains a thorough discussion of the topic and extensive code - both examples and a reusable class library. This is a must read for every Java developer.
24 of 25 people found the following review helpful
Format: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.
17 of 18 people found the following review helpful
By Y. Keselman
Format:Paperback
The book is a valuable resource for experienced programmers who are trying to write large, complex, real-life concurrent Java programs. The book discusses in depth many concurrency-specific issues you can run into, especially with Java. It gives tons of useful advice (in rather abstract form), both in text and in code (see the book's website for more complete examples). The book is full of useful frameworks and patterns.
However, it make take you a while to understand most of them. The author is fairly careless about the reader, and lets the reader do all the work. To understand one paragraph you may have to browse through 10 other pages, because that parargraph would reference them directly or indirectly. For example, to understand what is meant by "volatile" or "ThreadLocal", it helps to read several pages that precede these terms (and in other instances, you'd have to read several pages that follow). In other words, the book is not easily digestible, and many sections have to be chewed and re-chewed. The best way to approach the book would be to read it in "circles/spirals" and "in no particular order".
On the whole, the knowledge and understanding you get out of the book is worth the effort, but, I wish the author showed a bit more understanding for the reader. With a bit more work, the book could have been not only informative but also readable. For now, its readability is on par with a dictionary.
Most Recent Customer Reviews
5.0 out of 5 stars
Concurrency implementation.
Before ths book, I was excited by "Programming with Posix Threads".
although this book was published in 1999 ,
Java Concurrency Implementation has been great... Read more
although this book was published in 1999 ,
Java Concurrency Implementation has been great... Read more
Published 18 months ago by ChoHangJong
5.0 out of 5 stars
Very Good
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... Read more
Published on February 6, 2009 by J. Neal
3.0 out of 5 stars
Too Theoretical
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... Read more
Published on October 23, 2007 by Ray Ye
2.0 out of 5 stars
5 for knowledge; 0 for the writing -> 2.5 -> 2
Sure he knows his stuff but doesn't have a clue on how to write. This is appallingly poorly written. Read more
Published on April 19, 2006 by Mr. Patrick M. Thompson
3.0 out of 5 stars
If you want to program concurency in Java you need this book
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. Read more
Published on January 15, 2006 by Omar Bounouioua
5.0 out of 5 stars
Great Threaded Programming Information for More than Java
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... Read more
Published on January 9, 2006 by ActiveScott
5.0 out of 5 stars
Will make you a better programmer, but not for beginners.
This book is great but don't read it as your first introduction to Java threads.
This book is not about Java threads per se, but more about design patterns and good... Read more
This book is not about Java threads per se, but more about design patterns and good... Read more
Published on October 29, 2004 by Thomas Alison
1.0 out of 5 stars
"This is Phylosophy of concurrency".
This is not "concurrent programming".This is only "philosophy of concurrency".I think so too.
Published on July 5, 2004 by T.Murayama
5.0 out of 5 stars
Excellent, Deep & Clear
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. Read more
On the one hand, he does much more than cover the API. He teaches you to *think* & understand multithreades. Read more
Published on March 15, 2004 by Sollie
2.0 out of 5 stars
IQ test
I agree with other reviewers that this book is hard to read and understand. To me this is more like an IQ test, if you are smart enough then you get it, otherwise, get lost and... Read more
Published on March 13, 2003
What Other Items Do Customers Buy After Viewing This Item?
Sell a Digital Version of This Book in the Kindle Store
If you are a publisher or author and hold the digital rights to a book, you can sell a digital version of it in our Kindle Store.
Learn more
