This is a very nice book to get to know all the tools of Java 5 for concurrency support.

This is the very best book available on concurrency. It covers all the Java 5.0 paradigms and goes from the explanation of volatile/final/mutable/immutable to advanced topics like re-entrant locks.
The best part about the book is Mr Yuk an icon to denote really bad thread unsafe code examples and comparison to different implementations that are correct -you will see from the first day onwards the mistakes that you have been making in your existing code. Very practical; Good explanation, lots of sample code.

Close your eyes look no further and get this book -you will not regret it.

An awesome book on concurrency that all Java programmers ought to read before embarking on anything more complicated than the primordial Hello World application.

After reading this book you will probably thank God that you haven't been using threads, but with that being said this book contains all the information you need to start writing code that walks the straight and narrow path.

This is "the" authoritative book on java concurrency. However, apart from some java specific items, the book is an excellent source on parallelism in general. Do not even try to implement parallelism without "reading and understanding" this book. Highly recommended !!!

This was a solid book to gaining an understanding of Java concurrency, especially the new concurrency features introduced in Java 1.5

Though the book is admittedly good and valuable in content, the paper quality of the pages is absolutely horrible! One can see through to the next page, and using a highlighter for emphasis is next to impossible. I will never buy this book as long as the paper quality is so poor (as my colleagues have also mentioned).

It's a great book that everyone should read. You'll definitely wind up stopping yourself from some common mistakes that result in the ever-so-common "WTF?!?!!?" reaction when debugging for a couple hours and seeing things working just fine, but not working on and off in production. Yeah... then it dawns on you that there's a synchronization issue.

This book helps keep those kind of issues in mind much, much better.

The only downside to the book is that it's a complete bear to read. It's just an exceedingly difficult book to work yourself through. I actually finished two other books while reading it. It's just really heavy without any real breaks in there to keep it entertaining.

Again... great book, but in a next revision I hope the authors take some time to just make it a bit of a lighter read.

Another "A-List" Java book that needs to be in every Java reference library. "Java Concurrency in Practice" provides clear and concise coverage of a nontrivial subject.

In terms of the concurrency pragramming, this book is explaining more comprehensive concept and programming model of the thread programming. Also, it is good for upgrading to Java JDK 1.5 programming skills.

To sum, the author introduces the deeper and well understandable thread theory for Intermediate and advanced java programmers.

For me, the most helpful feature of this book are the advices about what not to do -- Best practices on Java concurrency. The authors addressed all the problems I've had with Java concurrency. For those are not using Java 5 yet, it is interesting to remind that the examples are implemented in Java 5.

I've been doing Java development for close to thirteen years now, and I learned an enormous amount from this fantastic book. For example, I knew what the textbook definition of a volatile variable was, but I never knew why I would actually want to use one. Now I know when to use them and when they won't solve the problem.

Of course, JCP talks about the Java 5 concurrency library at great length. But this is no paraphrasing of the javadoc. (It was Doug Lea's original concurrency utility library that eventually got incorporated into Java, and we're all better off for it.) The authors start with illustrations of real issues in concurrent programming. Before they introduce the concurrency utilities, they explain a problem and illustrate potential solutions. (Usually involving at least one naive "solution" that has serious flaws.) Once they show us some avenues to explore, they introduce some neatly-packaged, well-tested utility class that either solves the problem or makes a solution possible. This removes the utility classes from the realm of "inscrutable magic" and presents them as "something difficult that you don't have to write."

The best part about JCP, though, is the combination of thoroughness and clarity with which it presents a very difficult subject. For example, I always understood about the need to avoid concurrent modification of mutable state. But, thanks to this book, I also see why you have to synchronize getters, not just setters. (Even though assignment to an integer is guaranteed to happen atomically, that isn't enough to guarantee that the change is visible to other threads. The only way to guarantee ordering is by crossing a synchronization barrier on the same lock.)

I've seen hundreds of web site crashes. Every single one of them eventually boils down to blocked threads somewhere. Java Concurrency in Practice has the theory, practice, and tools that you can apply to avoid deadlocks, live locks, corrupted state, and a host of other problems that lurk in the most innocuous-looking code.

Very simple -- if you need to write a concurrent Java application you must have this book.
The book teaches you more than just the theoretical aspects of concurrent programming such as exclusion mechanisms, liveness and safety issues, it shows the correct way to do it in Java.
A comprehensive tutorial of the concurrency package provided in j2se 5 and 6 is given, and I think it is a crucial aid for writing correct and maintainable concurrent code in Java.
The advanced topics in the book give you a better understanding of the inner workings of Java and even the inner workings of compilers and modern processors and this is done without going into redundant details.

The only comment I have about the book, is that I would expect at least a chapter or two about parallel and distributed programming and the available Java frameworks that support it.

Don't think I can add much to the review of this title, it is simply one of the
best and clearest books on concurrency usage in Java applications.

This is a book about Java concurrency design, not merely how to use Java thread through a set of APIs.

Authors go through fairly deep on what the challenges are faced by Java developers on designing robust concurrent applications, what should be considered to balance design forces between liveness and safety, how to utilize parallelism to achieve better scalabilities, what pitfalls should be avoided, how to test concurrent applications. A lot of practical examples are given under the context.

Most of "new" components in java.util.concurrent package are explored and analyzed, for what the thoughts are behind, why the design came the way it is and what balance it achieves. These components can be used as a basic building block for composing more sophisticated solutions to meet your application concurrency requirements.

Though the theories behind concurrency are not trivial, the book presents them in a very clear, concise and easy understanding way. It is a truly remarkable book for Java developers in trenches.

I'm sure the content is still superb. But the quality of the paper is pretty poor. The latest release of this paperback, 5th printing, July 2007, is printed on thin see-through recycled paper. I'm for preserving the environment, but I'm against paying full price for what seems like shoddy merchandise.

I tend not to buy international editions, precisely because the paper is so cheap that you can see right through it, making reading difficult. Sadly, this domestic edition suffers the same fate, albeit not as badly as some Low Priced Editions; it's merely annoying. Truth be told, other domestic full priced editions also have translucent paper; but I still don't like it, and the flimsy through-view paper in this book stands out. For example, with the pages flat, I can read parts of page 221 through the white space on page 219!

The book explains in detail the issues of concurrency. Although a complex topic, the explanations are crystal clear. Well worth reading by anyone writing explicit multithreaded code, or implicit multithreaded code such as anything in a J2EE app server.

This is an excellent book on writing good thread-safe java code. It starts out with the concurrency basics, but gets into some more complex code design. Since multi-threaded applications and multi-processor boxes are becoming more and more common, this book is a must-read for every software developer.

Simply put this book can be viewed from a love it or hate it perspective, but personally when i bought Java Generics and Collections ( O Reilly ) i was impressed by the depth of their coverage, it gave me that inside edge and the internal knowledge of generics and collections ( how they work etc. ) This Book works well in giving what to do, what could have been done better and some portions on Concurrent package, but simply put I AM NOT SATISFIED WITH ITS COVERAGE ON CONCURRENT PACKAGE!. if you stack up generics against this one, i'd say generics is 200% better than this one.

So yea i was a bit disappointed with the book. But hey, nothing works better than the Java Language Spec Third edition =). ( at least it gives you everything exhaustively ).

Regards
Vyas, Anirudh

Java Concurrency in Practice gives very complete coverage on the language's concurrency classes introduced in Java 5 & 6. It shows you the shortcomings of previous attempts at concurrency in earlier versions of the JDK, with great code samples.

This book is pretty comprehensive and goes through the thinking/theory of why things are written the way they are, it is not just a paper version of the JavaDoc reference.
It is also very, very readable. I am by no means experienced in concurrency problems, but it was very easy to follow through the reasoning and examples. (my background is a CS degree and 1.5 years in the industry)

This book is a must read, especially for Java devs. Even if you are not a Java programmer, it could still be an enlightening read because it tells you how to structure your programs to deal with concurrency and how to deal with concurrent stateful apps, which unless you are using Erlang, is something you have to deal with.

Perfectly lucid style combined with a number of architectural patterns makes this book a treasure. Totally love it.

I have been programming in Java for years, and yet I've generally ignored or otherwise avoided dealing with concurrency and synchronization at every opportunity because I found it so daunting. This book broke down that barrier for me and helped me to understand what I needed to do to write correct concurrent programs. In particular, the book provides concrete instructions that I was able to apply to projects that I am working on right now.

I would highly recommend this book to any Java programmer, as you are probably missing out on part of the capabilities of your language (and/or writing incorrect programs!) until you read this. It's probably not a bad lesson for developers of concurrent software in any language, but the concrete instructions regarding Java were really the most valuable part of the book to me.

Essential reading. Extremely well organized and written. Everything you need to know is covered in detail. If you have not read this book, it's not likely that you will be able to write correct concurrent applications. There's just way too much to know.

Goetz did a really nice nice job in putting together lots of issues on how to deal with concurrency in Java, not focusing only the util.concurrent/Java 5 API but how to make other aspects of the platform (such as frameworks, servlets and swing apps) to use them. The book is full of useful and detaild (although not boring) information and advice, using real examples.

I'm not a stranger to the java.util.concurrent package, but must admit that I learned and awful lot by reading this (really well written) book. But be warned: The more you know, the more you know you don't know...

This book explains a hard topic in crystal clarity. While doing that it provides invaluable expert insight into the topic. Also provides great explanation of java 5 concurrency utilities and how and where they should be used.
Concurrent programming is difficult and if you need to do it, you need this book.

I have only read first three chapters till now. But I can certainly say "This is a must have for all JAVA programmers.".

I am already fairly experienced at writing concurrent applications and bought this just to get a reference to the new concurrency features of Java 1.5. However, its so well organised and written that I have been reading it from start to finish just for the pleasure of it.

This book is a must-read for anyone working in java with the shared-memory concurrency model. Ideas are very clearly exposed & the new java.util.concurrent package is explained perfectly.
If you work in java with threaded code, stop whatever you're doing and read this book, now!

This is a very little-understood topic, especially among Filipino Java Developers. Reading it came at the right time, just when I'm starting to write some real concurrent apps.

This book helps even if you never plan to DIY concurrency, and are happy to rely on app server functionality. If you will never use concurrent or multithreaded Java - doubtful - JCIP is still useful because it helps you understand some Java concepts in a practical setting.

If you haven't, reading Joshua Bloch's Effective Java first is recommended.

A great way to get your feet wet with Java concurrency. It also grows well and will take you pretty far on the way to mastery (I'll let you know when I get there :).

Terrific coverage of advanced thread topics. You'll never look at your code the same way again. Great examples. Perfect balance between theory and practice.

This book is a tour de force. The subject matter is intrinsically difficult and frighteningly susceptible to detail. I knew I had gaps in my knowledge when I started to read it, but the extent of my ignorance was chilling.

The book chooses a very thoughtful level of abstraction which gives the reader the opportunity to absorb the essential problems and patterns without straying too far from the inconvenient realities, at the same time teaching a kind of framework for analysis of multithreading issues. It is a very well organized book that will serve as a fine reference after providing the initial learning experience. The book's focus on the Java 5 concurrency library makes both the lessons and the library accessible and easy to exploit. The lessons are deep and varied and without exception practical.

Practising multithreaded programming in Java without reading this book is like doing aerials without a net. If you choose not to read it, good luck, and I hope it doesn't hurt too much.

This is clearly one of the top notch Java books like Doug Lea's original "Concurrent Programming in Java". And like CPIJ it is scary. Can one ever get the concurrency aspects right enough? Are the books of other authors trustworthy (enough)? There is so little help from the language itself and the IDEs to get things concurrency correct. And the authors show in many examples, what all can go wrong and that our old "Von Neumann machine" intuition is plainly wrong and often highly misleading. With the inevitable concurrency, Java is in fact a language for advanced programmers. Things will in practice get worse due to the increasing ubiquity of multiprocessor computers even on the desktop.


The book is written by leading Java experts. It cites and uses in an unusually extensive ways some of the other classics in our Java world:
Arnold et al. "The Java Programming Language",
Lea "Concurrent Programming in Java",
Gosling et al. "Java Language Specification" and
Bloch "Effective Java".
It is helpful but not mandatory to know them. Better it is to have them handy to be able to quickly look things up. Most other referenced works are original articles.


"Java Concurrency in Practice" is written in a readable style - though the material is presented in an unusual dense way for an Addison and Wesley Java book. Expect an information density more like an O'Reilly one, but a lot lower than a Springer one. Anyhow the book gets easier to read as you and your understanding progresses.


The presented material relies on and explains the new concurrency features of Java 5 and even Java 6. But it is not a tutorial of the new concurrency classes. It is a high level introduction from the usage pattern point of view. It explains the new classes only as far as is necessary.


One of my favorite chapters is on testing concurrent programs. Yes, it is possible to make unit tests for concurrent classes. No, it does not look like it is much fun though. But, you get a good head start. Besides peer review you also find some testing help in static analyzers like "findbugs".


In summary I recommend this book as one of the core Java books. I still wish the world is - with respect to multithreading - easier and less intimidating.

I have purchased or been given about a hundred tech books over the past two years and read nearly none of them -- except for this one. With the multi-core era upon us, the topic couldn't be more timely and I can't imagine this book being written any better. This is the book I read when I have a spare minute, and I always learn something I can't imagine how I lived without knowing beforehand. Bravo Brian et al.