Customer Reviews

Concurrent Programming in Java™: Design Principles and Pattern (2nd Edition)

5 star:		(25)
4 star:		(7)
3 star:		(4)
2 star:		(7)
1 star:		(4)

 

 

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.

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.

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.

Concurrency is difficult to get right. If you're going to be doing concurrent programming - in any language, really - then you should have this book in your toolchest. Even if you've been doing multi-threaded programming for years, CPJ is likely to make you better at it. The book represents the latest thinking and advances in concurrency, and judging from the increase in scope over the first edition, it would appear that the state of the art is evolving rapidly.

The second edition is a big improvement over the first: it's better-organized, better-written, and covers much more ground. It also has better treatment of Mr. Lea's "util.concurrent" package, a set of useful synchronization classes that will undoubtedly find their way into the Java platform at some point.

This is a hard book to read, which is undoubtedly why it gets so many negative reviews from confused readers. You can't just browse through it in an hour and then expect to be able to write a multi-threaded web server. It covers enough material to fill a grad-level course in CS, and it helps to have a CS degree or the equivalent to get the most out of it. There are probably much better books out there if you want to get "up and running" with threads quickly. If you ever hope to do anything reasonably complex with threading, though, you should get this book and study it carefully.

Lea's book covers a wide variety of issues regarding concurrent development, and in adequate depth for what I believe to be the intended audience, namely working developers and not computer scientists nor students with no prior exposure to concurrent development. The solutions to standard problems described within are for the most part well-accepted, but presented with a minimum of fuss allowing one to see the end results without endlessly pondering alternatives. All in all I think this is a solid book written at an intermediate level of difficulty with useful applications for working developers. As an aside, don't be put off by reviews like that of "arthur" below; the fact that he completely misses the point of a simple code fragment (if the operation were performed as n+=2; instead of n++;n++; then n could never be odd and it wouldn't be possible to illustrate this simple data race example, which is still too much for arthur to handle) demonstrates vividly that this book is not ideally suited for those with no prior experience with concurrent development, or people like arthur who think anything but a "For Dummies" book is high-falootin'.

I have both Doug Lea's "Concurrent Programming in Java" and Oaks and Wong's "Java Threads". Doug Lea's book is by far the most comprehensive. The book focuses strongly on applied uses of locking mechanisms and covers a great deal of the theoretical basis of monitor-based locking schemes. The book is not easy reading though -- it is extremely dense. It has applicability outside of the Java programming environment and I recommend it to you if you are interested in the theoretical side of concurrent programming. Oaks and Wong's book is far less academic. It is an extremely easy read. Notwithstanding the fact that it is 250 pages, it can easily be read (and understood) in an afternoon. Their approach is much more practical and focuses on Java's support for concurrent programming. If you need to dive into multi-thread programming in Java then I heartily recommend this book to you as it will get you started quicker than Doug Lea's book. If your interest is in concurrent programming in general or if you are using a different language, then Doug Lea's is probably the more suitable.

This is unquestionably the best text on concurrent and multi-threaded programming in Java. If you or your team are writing multithreaded software in Java (and this includes awt and swing applications as well as server side), you simply must take the time to study this book. CPJ matters just as much as the JLS or the JPL and you will be rewarded many times over for the investment. Newcomers to Java concurrent programming may want to start with Kramer & Magee's book first.

Understanding Java concurrency requires one tostep outside the language proper: it's neccessary to stop pretendingthat Java is platform independent in order to write reliablemulti-threaded code. You will have to understand the Java memorymodel, how OSes manage threads natively and you will have to make theeffort to grasp some difficult material...

Yes, this material is tough, but this is because concurrency is a tough subject. Folks who don't realize this have usually been fooled by the deceptive ease with which one can create, start and synchronize threads in Java.

The author presents the principles of concurrency in a structured and lucid manner. He presents patterns which have proven successful in concurrent applications, and at the same time exploits patterns to the full as a means to communicate the concepts.

The new information which has been added concerning the memory model, cancellation and portability are welcome additions to the first edition.

Indeed, from cover to cover, the contents of this IT masterclass are *juicy* to say the least!

I bought CPJ because I had a concurrency problem at hand (writing a an efficient cancelable timer class) and had hoped to find a quick solution here. But what! Doug Lea is not in a hurry and takes his time to introduce and explain all the nitty-gritty of Java concurrency. I thought it wasn't necessary to learn about all this, but now I agree that you need to see the greater picture before you go off and implement even small solutions. Reading this book leaves me wiser than ever before and confident I could attack almost any concurrency problem in Java! (And it took me two weeks to solve my problem, when I reached page 200 or so, and it was piece of cake then.)

If you know what Design Patterns are and how to apply them then this is good book. It covers the basics of Concurrent programming and then explains some patterns based on these concepts and how can they be applied. However, if you don't have ANY clue what patterns are; you might find this book a little out of your league.