Java Concurrency in Practice | 
 enlarge | Authors: Brian Goetz, Tim Peierls, Joshua Bloch, Joseph Bowbeer, David Holmes, Doug Lea
Publisher: Addison-Wesley Professional
Category: Book
List Price: $54.99
Buy New: $30.48
You Save: $24.51 (45%)
New (34) Used (13) from $29.61
Rating:  50 reviews
Sales Rank: 9939
Media: Paperback
Pages: 384
Number Of Items: 1
Shipping Weight (lbs): 1.3
Dimensions (in): 9.1 x 6.9 x 0.9
ISBN: 0321349601
Dewey Decimal Number: 005.133
EAN: 9780321349606
Publication Date: May 19, 2006
Availability: Usually ships in 1-2 business days
Condition: All orders ship same business day via standard shipping (USPS Media Mail) if received by 1 PM CST.
| |
| Accessories:
|
| Similar Items:
|
| Customer Reviews: Read 45 more reviews...
The definitive book on concurrency in Java May 29, 2006
calvinnme (Fredericksburg, Va)
57 out of 60 found this review helpful
Concurrency, in the form of threads, has been present in the Java language from its beginning, and this book is all about concurrency in the current and future versions of Java with an emphasis on writing practical code. This book does for concurrent programming in Java what Geary's series of books did for graphical Java - it moves concurrent Java programming out of the realm of applets containing bouncing balls and into that of providing real solutions for professional programmers.
This book is not meant to be an introduction to concurrency in Java. Its intention is to offer practical design rules to assist developers in the difficult process of creating safe, fast, and high-performance concurrent classes. While many of the general concepts in this book are applicable to versions of Java prior to Java 1.5, most of the code examples and all the statements about the Java Memory Model assume Java 1.5 or later. By "later" I mean that some of the code examples use library features added in the not-yet released Java 1.6. After the introduction, which consists of Chapter 1, the book is divided into four parts:
Part one, "Fundamentals", (Chapters 2-5) are about the basic concepts of concurrency, thread safety, and composing thread-safe classes from those concurrent building blocks provided by the Java language. Chapter 2, "Thread Safety", and 3, "Sharing Objects", include nearly all of the rules on avoiding concurrency hazards, constructing thread-safe classes, and verifying thread safety. Thus, these chapters emphasize theory and have less code than other chapters in the book. Chapter 4 , "Composing Objects", covers techniques for composing large thread-safe classes from smaller thread-safe classes. Chapter 5, "Building Blocks", covers thread-safe collections and synchronizers, which are the the concurrent building blocks provided by Java. To conclude the section, the authors work through the steps of building an efficient, scalable result cache that could be used in a web server. A summary of the most important rules presented in Part one occur at the end of the section.
Part two, "Structuring Concurrent Applications", describes how proper use of threading improves the throughput and responsiveness of concurrent applications. The topics covered in this section include identifying tasks that can be run in parallel and programming them as such, proper termination of tasks, using thread pools for greater efficiency in multi-threaded systems, and finally improving the responsiveness of single-threaded systems, GUI's being the most prominent example.
Part 3, "Liveness, Performance, and Testing" is concerned with ensuring that concurrent programs actually do what is expected of them and do so with acceptable performance. The authors describe how to avoid situations where a thread waits forever, also known as a "liveness failure". Also included in this section is an excellent explanation of the use of the "ThreadLocal" class and how it makes it much easier to manage the process of associating a thread with its per-thread data.
Part 4, "Advanced Topics", covers issues that will probably be interesting only to experienced developers. These topics include explicit locks, atomic variables, nonblocking algorithms, and developing custom synchronizers. Any of these techniques, explicit locks in particular, can cause chaos when done incorrectly. This book shows how to use these techniques safely and with confidence.
One of the things that makes this book so good are the many code examples. There are only snippets of entire programs included in the book itself in order to highlight the portions relevant to the concurrency issue being discussed. The code examples are either good examples, questionable examples, or bad code examples and are decorated with "Smiley Faces" that are either happy, concerned, or unhappy depending on the quality of the code. The full versions of the code examples, as well as supplementary examples and errata, are supposed to be available from the book's website. However, at the time I am writing this, they are not yet available.
Overall, I would say that this is the most complete and accessible resource on concurrency in Java I have seen in print. I highly recommend it.
Excellent coverage of Java multi-threading June 2, 2006
Kyrill Alyoshin (Toronto, Ontario Canada)
23 out of 26 found this review helpful
The book is by far the best one on Java concurrency. There is really nothing out there that has such comprehensive coverage of this topic. Doug Lee's book is a bit theoretical and somewhat dry, but would be a nice complement to this book if you want to think some more about concurrency. This book has a very strong practical vector. Coverage of Java 5 concurrency features is very thorough. The book is extremely well-written, relatively easy to read.
The book stands on par with such established Java book jems as Josh Bloch's "Effective Java", Eckel's "Thinking in Java" and Rod Johnson's J2EE books.
All in all, this is a definite must have for any Java specialist.
Clear approach to a complex topic April 10, 2006
Seattle Doug (Seattle, WA USA)
12 out of 14 found this review helpful
We've been reading a pre-release version of this book as part of a local study group and I'm very impressed with the treatment.
Concurrency is perhaps one of the hardest issues to understand well and it's equally difficult to explain all of the issues, but Goetz et. al. do a very nice job of explaining clearly the different ways a multi-threaded process can fail and then providing concrete design philosophies that will help address those problems.
In my experience, concurrency books often fall between providing too little detail ("just add synchronized to everything and all should be well") to providing too much ("details of how the Java Memory Model actually behaves on a multi-processor machine"). Java Concurrency in Practice seems to find a nice balance, e.g. thoroughly explaining why you need to worry about how values are "published" between threads but without swamping you with so much information about the details of how this is done by the VM that you're left gasping for air.
For me, this is a focus on the practical aspects of building multi-threaded applications in real world situations. In such cases, you need to fully understand the potential pitfalls and then you want to have a list of specific design methodologies which help avoid those failings. Java Concurrency in Practice does a nice job of providing both.
Must-read if you're working with threaded Java applications... October 7, 2006
Thomas Duff (Portland, OR United States)
6 out of 8 found this review helpful
It's common knowledge that you can easily get burned with Java programs that are multi-threaded. I would strongly recommend that if you are going down the multi-threaded path, you *need* to get this book... Java Concurrency In Practice by Brian Goetz. This bridges the gap between what the reference manuals say and how things work in the real world.
Contents:
Introduction
I. Fundamentals: Thread Safety; Sharing Objects; Composing Objects; Building Blocks
II. Structuring Concurrent Applications: Task Execution; Cancellation and Shutdown; Applying Thread Pools; GUI Applications
III. Liveness, Performance, and Testing: Avoiding Liveness Hazards; Performance and Scalability; Testing Concurrent Programs
IV. Advanced Topics: Explicit Locks; Building Custom Synchronizers; Atomic Variables and Nonblocking Synchronization; The Java Memory Model; Annotations for Concurrency
Bibliography; Index
This book picks up from the regular documentation on how specific synchronization and threading features work. Goetz does a relatively light introduction to the topic, and then starts into practical issues that you'll encounter in real programs and applications. For instance, a specific component, such as a collection, might be thread-safe. But what happens if that component is part of a compound function you've written? The compound function may well have "features" that you don't expect when running in the wild, since the threading issues now have to be considered at a level higher than the specific component. And being that you rarely have a clue as to how your program will mix with others, a bad design can lead to nasty intermittent threading bugs that are nearly impossible to consistently recreate. Goetz goes beyond the "write your code this way" material to explain how both code *and* design have to work in concert with each other to make sure a multi-threaded application behaves the way it should.
I was also impressed with the number of examples, both good and bad. By having a large number of "don't do this" samples, it's likely you'll see something that might be common practice in your coding style (but that will need to be changed). He also summarizes the material in gray call-outs within the flow of the text, so you can quickly grasp the one or two line concept that needs to be remembered and internalized in practice.
In a single word, this book can be summed up as "practical". Everything is focused on how things really work, and how to avoid common practices that will lead to major trouble. This is a great addition to the Java shelf of my library, and I recommend it with no hesitation.
The best book on Java in a long time April 18, 2006
H. Kabutz (Cape Town, South Africa)
12 out of 15 found this review helpful
Brian has a winner here. I was fortunate to obtain a preview copy from Brian Goetz and have devoured the book. This is the first book that I know of since Doug Lea's Concurrent Programming in Java, that addresses Java threading and concurrency with such vigor.
Each section has a solid example that will also stand up in the real world.
The book was put together very carefully, with great attention to detail, as is essential for a book about concurrency.
One of the best parts of the book was Brian leading me on all the time. He would show me a piece of code as a solution to a problem, and I would think of ways that it could cause problems. He then addressed those problems on his next page, but caused other problems. This carried on until the final solution, which was always elegant beyond anything I have written :-)
A solid 5 star rating for this book!
Definitely a good meaty book for Java Specialists.
|
|
|
