Rating: 
Summary: Excellent even if you don't use Java
Review: Think multithreaded programming is going to be easy? Think again. Unless you are working on very simple code, multithreading is hard.The goal of this book is to describe some general solutions to the worst of the common problems in multithreading. Sample code is written in Java, but the theory applies to any object-oriented situation. Read the book and you will save yourself a lot of trial-and-error learning. Some people complain that this book doesn't have enough working examples. Working examples are nice for beginners, but they are distracting for people who are more experienced. This is important - if you are looking for a handholder, this book will disappoint you. Try "Java Examples in a Nutshell" or another book for beginners. Multithreading is abstract and requires a firm background. If you are ready to work, this book will reward you. Another book to try, even if you are using Java, is "Pthreads Programming: A POSIX Standard for Better Multiprocessing". That book is aimed a C programmers, but again, the general principles apply. The nice thing about that book is it works at a low level, so you can really see what's going on.
Rating: 
Summary: Powerful, difficult and rewarding book
Review: This book goes WAY beyond basic Thread constructs and APIs. Written with extreme brevity (and therefore demanding of the reader) it is a classic among Java books and will consistently reward you through multiple re-readings. This is the most difficult of Java books to read but it is by long and far the most potent.
Rating:
Summary: A musthave for multi threaded programming
Review: This book is a must have for multi threaded programming, just as Stevens' "Unix Network Programming" was to tcp/ip socket programming. It is a book one would come back to read time after time. There are many code examples to illustrate various design patterns. It is definitely an advanced book beyong API and language tutorials. Just as Stevens' book, it is worth its weight in gold.
Rating:
Summary: Will make you a better programmer, but not for beginners.
Review: This book is great but don't read it as your first introduction to Java threads.
This book is not about Java threads per se, but more about design patterns and good object oriented programming practices as applied to concurrent programming (hence the title). Doug Lea is a university professor and this book has a very academic style, including a ton of references to an impressive array of concurrency and object oriented research. While this makes the material somewhat dense, it is very thorough and thankfully supplemented by actual code snippets (Doug Lea also makes significant contributions to the Java SDK and writes great code).
Especially notable are the sections on semaphores and locking in general. Users of util.concurrent (which directly supplements this book), and even the new Java 5.0 concurrency utilities (which were written by Lea and company), will get tremendous value out of these chapters as the locking strategies form the backbone of the higher level classes found in those packages.
For beginners, read "Java Thread Programming" by Paul Hyde, and then try this book.
Rating: 
Summary: Thick, dense, but why?
Review: 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.
Rating:
Summary: Thick, dense, but why?
Review: 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.
Rating:
Summary: Extremely Theoritical
Review: This book mainly goes over the theory of Java Threads and works more as a guide to thread programming than a how-to book. Although the infomation inside the book is informative, more details regarding the thread classes and examples of their use is what is missing from this book. If one already know the java thread classes and wants better design in their programs, this is your book. If you are starting out and know nothing of threads or the thread classes, search elsewhere for help.
Rating:
Summary: a must read for software designer/modeler
Review: This book not only covers concurrent programming techniques
(which is *very* useful btw), it also addresses more important issues of OOA&D applicable to Java, that is, reader gets not only useful examples of code, but learns *how to* design & model Java applications.
Which is IMHO is much more valuable than the rest of the books going over the language implementation specifics.
Great job!
Rating:
Summary: Good Solid Information
Review: This is a good, solid book. I don't understand some of the comments here - although not aimed at people with little programming experience, it is not impenetrable or badly written. It is not an academic textbook, but neither is it an inspirational classic. It's simply a good explanation of many of the issues involved in concurrent programming - the best I have read. An experienced Java programmer who has already used and worried about threads could read this in a couple of days and learn a great deal - at least, I certainly did. The emphasis on patterns really helps - this is the first book I have seen that uses patterns as a tool and succeeds. They clarify the argument and let the reader decide whether they want to continue with a particular section or skip over to something more interesting. Some of thread programming is difficult and, at least at the moment, there is no way to avoid thinking about the problem - but even in the detailed discussions of the final chapter, concentrating on particular examples, there were useful general comments. My only criticisms are: (1) The organisation of the book wasn't as clear as it could be - it wasn't until I had read it from cover to cover that I felt I could find particular items of information. (2) There was little mention of Hoare's CSP/occam and the related Java work done at the University of Kent (I'm not an expert on this, but I found that work very useful and wished it had been discussed here). Amazon doesn't seem to like links from its pages, but I am not connected with these people and think readers here would be interested in this, so please - leave in this pointer: http://www.cs.ukc.ac.uk/projects/ofa/jcsp/ Thanks! Incidentally, if you are hoping this is a manual for Doug Lea's respected concurrency package - it isn't. I read the book hoping it would be, but I wasn't disappointed because, once I had finished the book, I found the package (with the online docs) easy to understand. So the book complements (and funds!) the package, but isn't a manual - it's much more useful than that...
Rating:
Summary: Deeper than you first realize
Review: This is an excelent book. Basically, it's a thorough review of concurrent programming with Java thrown in so people will buy it. The information is presented in a very clear and straight forward manner, and applies to concurrent programming in any language and platform. This should be a classroom textbook. I consider myself experienced in multithreading, and after this book was highly praised by a coworker, I read it looking for big relevations. I didn't get any ... until I finished the book and thought about what I had read. This book reviewed the fundamentals I hadn't thought about for a long time. After all, if you have thought about memory concurrency models and proper data hiding between threads, avoiding monitor deadlocks becomes much easier. To me, the big downside of this book is that even though this book is written so that it can be understood by a novice, a novice will not realize how important and far-reaching the 'simple' topics are!
| 
