Rating: 
Summary: Excellent, Deep & Clear
Review: Doug Lea does an excellent work.
On the one hand, he does much more than cover the API. He teaches you to *think* & understand multithreades. Example: he doesn't just state the java API won't let you modify a datastructure while iterating on it. He goes further to explain *how* java prevents this, and then details several methods to work around it. This particular example has greatly helped me with a project I'm on.
On the other hand, I found the explanations clear and easy to follow. Great book...
Rating:
Summary: Future of concurrent programming in Java?
Review: Doug Lea's util.concurrent library, or something very similar is currently under evaluation for inclusion in JSDK 1.5. Java synchronization primitives as it stands are still too low level for many applications. Developing multi-threaded applications is difficult - even deceptively simple constructs like read-write locks (concurrent reads, exclusive writes) are notoriously difficult to get exactly right. This book assumes some familiarity with the basic Java synchronization primitives since it doesn't dwell much on explaining them. It isn't a reference manual on the util.concurrent library either. What this book does quite successfully, is bridge academic theory and practical programming to help the patient reader develop a real understanding of concurrent programming. Most programming books focus on the "what" or "how-to" aspects - this tackles the "why". A useful book considering there are currently very few design patterns, and refactoring strategies available to resolve concurrent programming problems.
Rating: 
Summary: IQ test
Review: I agree with other reviewers that this book is hard to read and understand. To me this is more like an IQ test, if you are smart enough then you get it, otherwise, get lost and those who gave this book 5 starts will simply say: he does not understand a thing but the book is really great.
So, all my fault, I should not buy this book at first and since I've bought it I should nod my head and say:
"hmm, that's right, this is really a wonderful book."
I wonder why the author didn't write this book in Chinese.
Rating:
Summary: Read It Slowly
Review: 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.)
Rating: 
Summary: Excellent for the experienced
Review: I found the book to be excellent because I need a book that would allow me to map my knowledge of concurrency from other languages to Java. The book covers a lot more than just the syntax, such as providing the theoretical side of handling concurrency and the design patterns involved.If you are a novice to concurrency, then the theoritical side will do you a lot of good. For myself, it was a good refresher. The book is definitely worth the money.
Rating:
Summary: Not light bedtime reading
Review: 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.
Rating:
Summary: I just don't get it...
Review: I just don't understand how this book got all these 5 star reviews. I don't consider myself a beginner -- but I just could not read this book. It just jumps all over the place, using terms not in common practice, and not really building on anything. There were times I struggled to understand a concept only to realize that it was just something really simple. Other times, the topic ended just when it was getting interesting.
Rating: 
Summary: Way over my head!
Review: I tried hard to understand the content of this book however,it made litte or no sense to me. I am a novice Java programmer but have several years of experience in other programming languages. Don't go for this book unless you're a very experienced with Java. Java consultants who work with me admit they understand only parts of this book.....
Rating:
Summary: Great book for the real world
Review: If you are a java developer who needs to design a real concurrent application you will be glad you bought this book. Concurrent programming brings with it a special set of problems and explains behaviour (for example, in the java memory model) that can safely be ignored in a single threaded environment. Doug Lea presents real world concerns and guides the reader through the design strategies that can and should be used to address them in a safe and reliable fashion. If you are looking for a "threading cookbook" (see previous review) that presents the API in a recipe style structure then this book may not be for you. If you want to become a qualified "threading chef" who is able to reason and apply sound concurrency principles then this book will teach you much of what you need to know to be successful.
Rating:
Summary: Good book if you have experience in Patterns
Review: 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.
| 
