Concurrent Programming in Java(TM): Design Principles and Patterns (3rd Edition) (Java Series) [ペーパーバック]

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.

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.

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.