Rating: 
Summary: Doug Lea Makes allBlevoloskovolokians Proud
Review: In the great land of Blevoloskovolokia there are few books allowed by the government. Their strong censorships laws current prohibit all books except those by Marcel Proust, and soon Doug Lea. Doug Lea's book does a fabulous job of explaining Concurrent Programming in Java, a topic that all common folk should be well informed about. I strongly urge you all to buy several hundred copies of this book. It is fabulous and you won't regret it.
Rating: 
Summary: Was this book about Concurrency in Java?
Review: Java threading is a very fishy issue, the most OS dependent side of Java, hard to fully understand/debug/optimize. I was/am looking for a good book on the topic, but some authors think that writing a book is about showing off they know about(have dedicated their entire livez to) their domain of expertise. I was just looking for a book about well, ... "Concurrency in Java", but the author went on boasting about his general knowledge of concurrency talking too generally more about OS's than Java itself. This book is, indeed, very little about Java, I wonder what is the fundament for the - SO - favorable reviewes by other readers. Maybe the whole intention could be clear with a better title "Introduction to the Philosophy of concurrent programming, with some Java dressing". But then the book wouldn't have been bought by anyone, who blaims him, Sun, Addison Wesley. Some people forget that the cooking business is primarily about making food, and programming is about writing code. There are no running examples in Java, of the like you can find in "Core Java 2", by Horstman/Cornell, to illustrate what he is talking about; just sort of pseudocode with Java sintax, the author in some cases, openly recognizes it, stating: "no implementation code". You could check out yourself what I am talking about getting the books on your hands and going over it, try to find only one explanation backed by a running example. In some the best adjective that fits to describe his examples is practically "stupid". While talking about Synchronization Section 2.2 Pg. 75, he describes the following class: class Even{ private int n =0; public int next(){ ++n; ++n; return n;} } When class Even{ static int n=0; public int next(){ n+=2; return n;} } Would solve this problem without any further mystic and blah, blah. I could possibly write a book about semiotics, with a lot of blah, blah on it, backed by a lot of literature with impresive names, then ask Addison Wesley for a catchy name and even make money out of it, but would it be instructive to other people? Again this is only my opinion, and I am also interested in "Phylosophy of concurrency", you should check out yourself before paying for this book. To at least know what you will get. Thanks
Rating: 
Summary: Good overview on concurrent programming issues
Review: 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'.
Rating:
Summary: An Absolute Must-Have for Concurrent Object-Oriented Design
Review: Most Excellent! Doug Lea discusses concurrent OOD and OOP issues which I have found nowhere else. This book is a must-have for any OO designer/programmer intending to use concurrent techniques. The principles and patterns presented are applicable to implementation in any OO language.
Rating:
Summary: Well worthwhile
Review: Really informative. Seems to offer a "2 in 1" deal where it provides information on both concurrency and patterns. Not a light read as was the case before but the information is worth the effort.
Rating:
Summary: Excellent
Review: 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.
Rating: 
Summary: Awful! Save your money.
Review: The author provides no insight into how Java concurrency actually works, or how to best exploit it. His style is full of obfuscation and needlessly difficult to read. Just as K&R's C is known commonly as "the white book," Lea's "Concurrent Programming in Java" is known around here as "the badly written book." Skip it.
Rating:
Summary: Good for experienced programmers, but not as intro
Review: 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.
Rating:
Summary: It's a good book, but it may not be worth the effort
Review: The other reviewers weren't kidding about this book being dense and difficult to read. The problem I have with it is not its difficulty but because most of it is cause by poor presentation and organization rather than the subject itself.
Rating:
Summary: Best Java threads book for working developers
Review: There are only a handful of books out there that address how to implement sophisticated concurrent development techniques in Java, and this is the best of them. It's definitely a book for working developers though; if you're like me you visited concurrency ad nauseum in your operating systems class(es) in school, and want to get down to business with multithreading in Java instead of rehashing semaphores or POSIX threads or any other topic which won't contribute a whole lot to a real Java project. That being said I would definitely recommend either Silberschatz or Magee for a solid treatment of academic concurrency issues, although this book could suffice for a lot of people as it does discuss semaphores, monitors, transaction protocols and CSP to a good degree. Incidentally, it warms my heart to see that few Amazon users (3/26 for one review, 8/18 for the other) pay any attention to idiots like arthur who choose to conduct a flame war via book reviews, being clearly ignorant of both the subject matter and the forum in which it's being discussed (throw in basic grammar and syntax while you're at it). Hopefully he'll get his NNTP configuration back in order so he can return to alt.flaming.loser, and leave the pros alone.
|
