Best 5 Prices
Back to Results
Java Concurrency in Practice
Brian Goetz
$25.99 *
* Rental Price
Java Concurrency in Practice
Brian Goetz
19th May 2006
$33.25 *
* Rental Price
Java Concurrency in Practice by Brian Goetz, David Holmes, Doug Lea, Joseph Bowbeer, Joshua Bloch, Tim Peierls (2006, Paperback)
Brian Goetz
$35.00
Java Concurrency in Practice
Brian Goetz
$37.79
Java Concurrency in Practice
$53.65
Java Concurrency in Practice
Reviews 
Absolutely esential
05th September 2010
A comprehensive introduction to concurrency in Java, updated to cover the new executors/thread pools/futures paradigm. Spends a lot of time on the basic concepts of concurrency and then reviews basically every concurrency primitive in Java. I can't recommend this enough.
Highly Applicable for Fast Improvements
24th August 2010
After just the first couple of chapters I was able to fix several major bugs in my multithreaded applications. I have a number of Java certifications, but I would never have known about classes like AtomicInteger and AtomicReference without reading this book. It is definitely important to get the most performance possible out of your programs, especially in a service-oriented environment with lots of whining customers and little budget for hardware upgrades.
I was really impressed with the ExecutorService framework for fixed thread pools. I was asked to create a pooling mechanism simulating an application server that can be used for standalone testing. I originally created and managed the threads myself in an array, but this book gave me the information for making more use of the Java API in keeping the code clean. Using Callable instead of Runnable is great for getting results from your processes after they complete, and Future gives you a hook for cancellation/interruption.
There is a really interesting discussion on JVM shutdown. I have sometimes had processes that threw a Runtime exception but still held a database lock, causing deadlocks and contention later on. This recommends doing the final resource cleanup in the finally block of the "run" method. However, what if a "grid" monitoring process forces shutdown of my application? Would the Object's final() method insure that that my resource was cleaned up so that no lock is still held by the grid's JVM? The answer seems to be that the final method is less reliably called than the finally block, and that you should make your tasks "interruptable" by polling an unbounded queue or calling the thread's isInterrupted() method frequently. My questions aren't all answered on this, but I still have another 150 pages to go in the book.
Great book! Highly recommended.
21st June 2010
Before purchasing this book I borrowed it from a friend. Unfortunately he needed it back before I could finish, but it didn't matter because I had already decided it should be part of my Java book collection. It fits right in with my other two favorite Java books, Effective Java and Java Puzzlers. This book does a great job of explaining concurrency in the Java language and the best practices. The book not only gives examples of what you should do, but also what not to do. The majority of the book describes Java concurrency practices at higher levels, but the last chapter also describes the Java Memory Model for those wanting to tie it all together. I would consider this book to be for intermediate and advanced Java programmers. As the book states, it is not an introduction to concurrency so you should at least have a good understanding of Java threading basics before jumping in.
Good for beginners, but a drag otherwise
06th June 2010
I am surprised to find the majority of the reviewers rated this book 5. I find that this book is loaded with noise and you will have to wade through the authors excessive obsession to state the obvious over and over again, even in its "advanced topics" section. Such as:
"Performance is a moving target; yesterday's benchmark showing that X is faster than Y may already be out of date today."
Also, some of its examples uses non-standard annotations - @ThreadSafe, @GuardedBy, @NotTheadSafe, etc - that the authors hoped will be part of the JavaSE 7.0 release. (NOTE that this book was written when Java 6 was in beta stage)
Great book!
16th May 2010
The most comprehensive java threads book I have ever read. It gives an in depth knowledge of Multithreading issues and how to address them in many different ways, either by using the java.util.concurrent package or by the primitives wait/notify/notifyAll. As to the latters, it sheds a clear light on how to avoid issues like missing signals and othersl.
Reviews supplied by customers at Amazon.com
