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.

Before ths book, I was excited by "Programming with Posix Threads".

although this book was published in 1999 ,

Java Concurrency Implementation has been great resource for me.

if new language is created sometimes,

I would like to write book like this as long as it is possible . ^^;

The book is great. It has a lot of good concepts in it. You will learn a lot from this book. Just be prepared ... it is pretty heavy. The way it is structured and written can be tough to read, but once you get comfortable with the style, you will learn a lot. If it was easier to read, I would give it 5 stars!

The book is very good in explaining the details of Java concurrency model. It is pretty old, but that is good too, because instead of simply describing new solutions, it actually explains why these new solutions were necessary in the first place.

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 Mono/.NET). Unlike other reviewers here, I encourage so-called "beginners" to read this book. He has plenty of examples so you will not get lost, and this *is* the right way to do things, so start with this one.

It's the worst book of all the tech books I have read. No proper organizing. You dont feel like reading this book at all when you start. The content is clumsy.

Book is a little dated now but the principles in this book are still sound. Writing is informative and coherent. Would recommend.

This book is thick, dense, and not as good as other's think it is. (But it isn't without value to the RIGHT audience).

In summary:

The write style makes it hard to read.

The organization makes it hard to read.

Don't kid yourself that this is anything other than a book about Java multi-threading

There is more theoretical information in here then you are likely to find in other Java multi-threading books if you can slug your way through it. (and I mean useful theoretical information).

If this is your first try into multi-threading you should probably look elsewhere. (I would only rate this book as a two star for beginners).

The details:

The book is written in a very academic style like a very long conference paper. Now don't get me wrong, I get tired of the O'Reilly down home writing style after a while as well, but I have seen better writing (through not by my hand) that makes things clear and easy to understand. I think one of the reasons this book is dense is that the writing is not as clear or as well organized as it should be.

While there are many parts of this book that do apply to multi-threading in general a lot of it does not. Believe it or not but the Win32 API provides a vastly superior threading library than Java does. (I don't know if this is part of Java's keep it very, very simple design philosophy, the need to run on many platforms so use the least common denominator approach, or something else. I do wish SUN would fix the threading API like they fixed the first Java windowing api however since it is frustrating to work with). So there is a lot in the book that does not apply to C++ multi-threading on Windows (and I suspect most versions of UNIX as well) and since the author does not mention what is and is not applicable I would NOT recommend this book as a general multi-threading theory book thinking you can apply what is in here to other languages and platforms blindly. (You could end up doing something the hard slow way because you are unaware of the fact that you can wait on several locks at once in other platforms - as only one example).

Now don't get me wrong, if you are doing Java multi-threading only and you want a strong theoretical base to work from and you have the time to sit down and read this book, I'd say it's worth it. If you need to know the basics in a hurry you may want to look elsewhere. (Somebody else here mentioned Oaks & Wong - I haven't read that book but it might be worthwhile as the first read on the topic).

I would not read this as my first book on multi-threading. If you've done multi-threading work in Java or on other platforms then this could be your first book on Java multi-threading.

I very nearly didn't buy this book on the basis of many reviews here, however I decided to take a punt and have a look.

I was astonished to find that I *really* got on well with this book; much of the philosophy makes perfect sense, the examples are lucid and the explanations are thorough.

Perhaps this book is not for the faint hearted, but as an experienced developer I found this book to be exactly what I was looking for in terms of how to properly use synchronisation and lock-free algorithms.

El libro es impreso de impresora y no imprenta. Esta maltratado y sucio. La peor compra que pudiera realizarse.

Excellent

Java hat sich weiterentwickelt, aber die Grundlagen sind gleichgeblieben. Nicht einfach zu lesen. Viele Verweise auf andere Forschungsergebnisse. Um die Grundlagen zu verstehen, ist dieses Buch sehr hilfreich.