Rating: 
Summary: THE BEST Java/Thread book
Review: Taming Java Threads by Allen Holub is THE best book dealing with Java and threads. Typically you can just pick any O'Reilly book for any subject matter and just assume it is going to be one of the best books out there. That is not the case here - Allen has written a very comprehensive book on threads in Java and covering issues related to multithreaded programming not covered anywhere else.Unlike a lot of people, I got exposed to Allen's writings via. his JavaWorld articles on Threading. That 9 part article offered a great treatment on Java threads and probably was a basis for this book. But the book is far more comprehensive and offers a great understanding of the basics of threads, and how to work with them correctly. This book is very extensive touching on every aspect of multithreading programming including AWT and Swing. This book is a must for anyone programming multithreaded applications in Java.
Rating:
Summary: THE BEST Java/Thread book
Review: Taming Java Threads by Allen Holub is THE best book dealing with Java and threads. Typically you can just pick any O'Reilly book for any subject matter and just assume it is going to be one of the best books out there. That is not the case here - Allen has written a very comprehensive book on threads in Java and covering issues related to multithreaded programming not covered anywhere else. Unlike a lot of people, I got exposed to Allen's writings via. his JavaWorld articles on Threading. That 9 part article offered a great treatment on Java threads and probably was a basis for this book. But the book is far more comprehensive and offers a great understanding of the basics of threads, and how to work with them correctly. This book is very extensive touching on every aspect of multithreading programming including AWT and Swing. This book is a must for anyone programming multithreaded applications in Java.
Rating: 
Summary: Interesting coverage of a complex topic
Review: This book is for the experienced Java developer who has a solid understanding of the basics of threads. If you have been working with threads and are looking for a book to help you avoid thread problems then this book may be exactly what you need. The author does an excellent job of explaining why threads are not easy to use correctly and then provides an extensive library of classes that can be used to overcome thread problems. These classes are the meat of the book. Each class is designed to solve a specific problem that using threads by themselves can create. In general the classes are explained well although there were several blocks of code that I thought deserved a deeper discussion. The topics covered are extensive: exclusion semaphores, counting semaphores, locks with timeouts, and read/write locks. The semaphore classes provided can solve a host of problems and are worth the price of the book by themselves. For Swing the author discusses timers, alarms, thread safety, observers, and multicasters. The discussion of Swing and threads is critical for Swing developers to understand but is often skipped over in books on Swing. However, I have one complaint with this book. The main reason for buying this book is the code but the author insists on either a mention in your about box or you must pay a license fee to use the code. For some corporate IT departments this could be an issue. (...)
Rating: 
Summary: Assumes you know about threads already
Review: This is an in depth detailed book. It is packed with insights and the nitty gritty you cannot find in most places. However, unless you have already studied threads and worked with them, the explanations can sometimes miss the mark. Early in the book an example of a Simple_notifying_queue is explained well, but quickly transforms into a discussion of the nuances of wait(). I was still hanging in until the next class, to help solve the wait() problem was difficult to follow. I finally realized he was using an anonymous inner class as a method parameter which implemented an interface and required variables in the method to be marked final in order to be able to use them. Ok, that was a good refresher, but why complicate threads with a first example using esoteric features of Java, negative logic for a conditional test that is suppose to return true, and all this after a discussion of thread priorities and process priorities and how bad NT is. If Java only has 10 priorities and NT has 7, they both sound a little weak compared to Solaris. But when you don't yet know threads, it is a discussion that leaves one baffled. I think you have to build slow, picking up steam as you lay a foundation. This book starts off addressing fellow thread experts. I do have to rate it high for the detail and depth, I only say it is not the first book you should read on threads. You have to already be accomplished to get it. Keep your level of understanding of threads in mind when purchasing and save this one after some decent exposure.
Rating:
Summary: Read Another Thread Book First
Review: This is an in depth detailed book. It is packed with insights and the nitty gritty you cannot find in most places. However, unless you have already studied threads and worked with them, the explanations can sometimes miss the mark. Early in the book an example of a Simple_notifying_queue is explained well, but quickly transforms into a discussion of the nuances of wait(). I was still hanging in until the next class, to help solve the wait() problem was difficult to follow. I finally realized he was using an anonymous inner class as a method parameter which implemented an interface and required variables in the method to be marked final in order to be able to use them. Ok, that was a good refresher, but why complicate threads with a first example using esoteric features of Java, negative logic for a conditional test that is suppose to return true, and all this after a discussion of thread priorities and process priorities and how bad NT is. If Java only has 10 priorities and NT has 7, they both sound a little weak compared to Solaris. But when you don't yet know threads, it is a discussion that leaves one baffled. I think you have to build slow, picking up steam as you lay a foundation. This book starts off addressing fellow thread experts. I do have to rate it high for the detail and depth, I only say it is not the first book you should read on threads. You have to already be accomplished to get it. Keep your level of understanding of threads in mind when purchasing and save this one after some decent exposure.
Rating:
Summary: Assumes you know about threads already
Review: What it is: a brief introduction to threads, and then a lot of strategies for re-implementing some of the thread-related classes that Sun provides (or fails to provide). If you are running up against the limitations of Sun's thread-related code and want to re-implement some of it, this book might be just what you're looking for. If you want to learn a lot about threads and how to use them correctly, another book might be better. What I liked: I found the writing to be relatively clear and concise. I didn't like much else about the book, but that's probably because I was really looking for a different type of book. What I didn't like: the author spends a lot of time complaining about things, some relating to threading and some not. I really don't care about the author's opinion of whether Sun should have made the default access for a method to be "package". The author comes across as a whiner because of all this complaining. Also, a big chunk of the book is taken up by copyright notices he sprinkles throughout his code. Finally, he doesn't use Sun's code style conventions. There is a reason Sun created these conventions: it's so all Java code would look similar and the reader doesn't get slowed down by an unfamiliar format. It doesn't matter so much for private code, but for publishing code in a book, there's no excuse for using a different style. (And of course the author wastes a few paragraphs complaining about Sun's code style too.)
| 
