Rating: 
Summary: Well-written book on threads
Review: (I read the 2nd. edition)
What I especially like about this book is that it doesn't only repeat what you could already learn by going through specifications and API-docs, but actually discusses the merits of the Java solutions with respect to concurrency. So you don't only learn about synchronization and thread scheduling, but also about the limitations due to the architecture of Java. What is even better: the authors propose succinct solutions for overcoming those limitations. This is all done by means of a limited number of examples that are developed in a way that pinpoints the problems and clearly illustrates the steps to their solutions. By reviewing these examples you can easily recall the flow of the argument.
Rating:
Summary: Vastly improved in the 3rd edition...
Review: (This review is for the 3rd edition of the book)
Thread programming in Java can be a great feature or the bane of your existence. If you need a good book for understanding the subject in depth, get a copy of Java Threads (3rd edition) by Scott Oaks and Henry Wong (O'Reilly). It's quite good...
Chapter list: Introduction to Threads; Thread Creation and Management; Data Synchronization; Thread Notification; Minimal Synchronization Techniques; Advanced Synchronization Topics; Threads and Swing; Threads and Collection Classes; Thread Scheduling; Thread Pools; Task Scheduling; Threads and I/O; Miscellaneous Thread Topics; Thread Performance; Parallelizing Loops for Multiprocessor Machines; Superseded Threading Utilities; Index
The first thing to note about this book is it's now in its 3rd edition, and apparently has been vastly improved. I never read the 2nd edition, but the reviews on Amazon are less than steller. The authors have updated the book using J2SE 5.0, which has improved the threading abilities of Java. As a result, there are fewer custom classes in the book that the authors deemed necessary to do more complex tasks. The focus has returned to core Java threading functionality available in the latest version of Java, so you'll be getting the most up to date information here. The subject matter starts off with the basics of threading, and then builds upon that information so that you can start to code and build complex threading applications. They also do a good job of noting the differences in 5.0 so that you can see where improvements have occurred. All really good stuff...
I enjoyed going through this book, and I'm sure I'll be referring back to it on a constant basis when my coding starts to get into any threading issues.
Rating: 
Summary: Java Threads
Review: Book provides basic useful information. Other than that, some of the contrived examples and sample classes are bad and wrong. Some of the stuff will not even work. The utility classes like TargetNotify are not useable. It would be better if they had tried to use them in some sample programs.
Rating:
Summary: 3rd Edition is a whole new book
Review: I also have an old copy of the 2nd Edition, which I would have given 3 stars. However, the 3rd Edition might as well have been published as a new book. I was pleasantly surprised to see that the organization, chapter layout and code examples are essentially all new - not just tweaked from the previous edition. If you're looking for a good book on threads, this is it.
The example code is well done, and the concepts are illustrated satisfactorily. If you download the examples from the web site, each chapter has a list of the code samples and the ant tasks to run to use them, which was a nice touch. While the concepts behind Java Threads apply to most versions of Java, I'd say this book is really geared toward the J2SE 5.0 environment.
It's too bad Amazon can't reset the rating for each edition, as the 3rd Edition is quite an improvement. Be sure to check out reviews starting in September 2004, when this book was published.
Rating: 
Summary: Be Carefull of this book
Review: I can not recommend this book. Examples are redundant (same code shown many times with small changes). While the code looks like it would work (I never tried it) the methodology leaves much to be desired. Much of the threading code in this book looks like old Unix style fork code pushed into a threaded Java environment. If you want to learn threads in Java, look elsewhere. If you already know threads in Java, then save your money. I see that a new edition is coming out soon, let's hope it brings the book up to speed.
Rating:
Summary: good explanations on a difficult subject
Review: i found the explanations good and have already applied what I learned
Rating: 
Summary: A good guide for getting started
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: Very Disappointed
Review: I have much respect for O'Reilly books but this is the second book from O'Reilly that I have thrown to trash can. The topic is very poorly covered - for example, the covers very briefly in chapter 2 about the difference between extending 'Thread' class vs. implementing 'Runnable' They states that this topic is 'beyond the scope of this book'. This is basic 101 on Java Thread - Runnable vs. Thread and Runnable is very prefered way. Why? Well, if you extends 'Thread', you cannot extends other classes. Also, you don't have to worry about changes into Thread class in the future.After reading first two chapters, I threw away the copy. You are better off with other books.
Rating:
Summary: Very Disappointed
Review: I have much respect for O'Reilly books but this is the second book from O'Reilly that I have thrown to trash can. The topic is very poorly covered - for example, the covers very briefly in chapter 2 about the difference between extending 'Thread' class vs. implementing 'Runnable' They states that this topic is 'beyond the scope of this book'. This is basic 101 on Java Thread - Runnable vs. Thread and Runnable is very prefered way. Why? Well, if you extends 'Thread', you cannot extends other classes. Also, you don't have to worry about changes into Thread class in the future. After reading first two chapters, I threw away the copy. You are better off with other books.
Rating:
Summary: Not for a threads newcomer
Review: I have read a great many books on Java, and have come to expect high-quality, no-nonsense writing from O'Reilly. Java Threads stands out as the worst book I've read from O'Reilly. For a time it was the only book that covered Java threads in detail, but that time has past, and there are far better sources of information out there. Programming with threads is complex, and though java has built-in methods to provide multithreading, java's thread-handling syntax won't do it all for you. For example, using the "synchronized" keyword isn't enough to make a program "thread-safe." Fine. But rather than discuss solutions to this, Scott Oaks rambles on teaching a solution, and then telling you why what he just taught you won't work. Certainly, this is a professional book, but there's no reason to make it inscrutible. My only real learning came from sifting through the example programs and trying to forget the first four chapters. If you don't already possess a good understanding of how to program using threads, this certainly isn't the place to start.
|
