Customer Reviews

Taming Java Threads

5 star:		(7)
4 star:		(3)
3 star:		(1)
2 star:		(2)
1 star:		(2)

 

 

A book like this is overdue. It fills the gap between dry academic books on concurrency and light-weight books that just repeat the spec. The book is directed at experienced java programmers who want to do threads the right way. It addresses how to solve classic deadlock and synchronization problems with extremely practical java code and techniques. This book is clearly written and it contains lots of well documented code. If you write threaded code, you should get this book.

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.)

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.

Of all the topics a programmer learns, it's been my experience that the two most complex topics are recursion, and multi-threading. Both require a different way of thinking about software, very much out-of-the-box thinking. So if threads are getting you down, Taming Java Threads is the book for you.

In Taming Java Threads, you'll learn how threads work, by examining practical applications that demonstrate key topics and which are backed up by theory. You'll learn about topics like mutex and lock management, timer threads, synchronization, and thread pools. The range of topics will interest both a beginner and an expert. But to my mind, the most important topic was GUIs and threads.

Older books on threads completely neglect topics like GUI design and Swing -- yet as Allen Holub shows in Taming Java Threads, threads are essential to the Swing event-dispatch queue, and a knowledge of threads is required to prevent unresponsive GUIs. The important information contained within these chapters should be required reading for Java developers. Without it, you'll write applications that can stall and freeze.

Taming Java Threads is a great guide to thread programming. If there is one flaw in the book I detected, it was that it failed to cover non-blocking I/O as an alternative to threads. Whether you've just learning Java programming, or you want to hone up on your thread theory, this is the book for you. -- David Reilly for the Java Coffee Break

Nearly a decade ago I had read Alan's 'Compiler Design in C' book, which was a surreal experience in learning from someone's self evident mastery of putting theory to practice. Taming Java Threads does the same for me. There is no other book (I repeat) on the market, on the topic of multithreaded programming in Java, which is as succinct, incisive and authoritative. A LOT MANY MORE people should be following his advise, than actually do.

Be warned that the writing style and level of discussion essentially assume that you do have a fair flair for all things Java and Object-Oriented. (Also, from years of suffering sustained abuse, I have become impervious to the opinionated, ideosynchratic approaches of authors living in or near Berkeley, CA. Your digestion may vary. OTOH, I do like authors who pick a problem and systematically club it to death!)

My only lament? (;-)) Life would be a lot easier for many of us, if those repetitive copyright statements did not exist. Purely on the merit of his serious contribution here, I am refraining from rating this book based upon my deep disagreemt with his sentiment in this regard. Frankly, I wonder what I would be able to do, or not, if many other books in my book shelf had taken the same approach. Remove them in the 2nd edition, please.

Typesetting is very bland. (Hey, pick up some TeX, Alan!)

-a

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. (...)

Don't get me wrong, this is a terrific book packed full of useful information and code to match. But Holub has not put the code in the public domain and if you use any code out of the book it must be accompanied by what amounts to an advertisement for the book in your program's About box. While this may be marginally acceptable for shareware developers, it kills the usefulness of the book in corporate development environments. If Holub removed this restriction I'd give the book 5 stars.

Great treatment of Java threads. Not a rehash of the API, but actual useful information on how to use threads to do work. I particularly like the object-oriented perspective of the examples. As one reviewer complains, the code is not in the public domain, but if you buy this book for the code, you're shortchanging yourself. There's much to learn here. Holub does a great job of explaining threads, locking, and their use in an object-oriented system.

While some of Mr. Houlub's discussions of Java threading are interesting on their own right, the introduction of Java 5 renders some of the contents out-dated. Since the author's code library discussed within the book is not open sourced, coders cannot use the contents of this book directly.

„Taming Java Thread" by Allen Holub covers all different facets of Java thread programming which are important for users. Topics discussed on 300 pages include architecture and details of multithreaded programming, mutex, conditional variables, threads in specials areas like singletons and Java UI programming.

The in-depth discussion assumes good knowledge of Java and Java threads. Thus this experts` book does not waste chapters with repeating well-known basics or the common API, it starts directly with high-end excellent details. Where other resources end this book starts. You directly see that the author is an expert with fundamental practical knowledge not only in Java but also in C++. This knowledge is not restricted to basic usage, he also knows and gives hints to platform specific behaviour.

Another advantage of this book is the excellent Java Swing discussion containing Timers, Alarms, Swing Thread Safety, Obeservers and Multicasters.

Finally Allen exposures design-flaws and critical issues in the Java multithreading archtitecture. He does not only point them out, he also gives great solutions how he would fix them.

This genial book was published 2000. Although it is five years old it is still state-of-the-art and I did not find a comparable book. Meanwhile many enhancements Allen provides are included in the Java 2 Standard Edition Version 5. If you directly use the concurrent packages of the Java Tiger release you profit from well designed abstractions saving you a lot of time and work. It is still very interesting to know the basics and backgrounds of the thread architecture and details. Especially for a UI developer the dedicated chapters are fantastic.

The only point which is a little bit strange for me is that Allen does not use the well-known and commonly accepted Java syntax: in his code examples he choses underscores to separate_the_different_sub_strings and notTheCommonlyUsedCamelNotation (he explains why he did so). New books and articles of Allen do use the camel notation.

I really hope the author writes a second edition discussing new thread functionality in Java Tiger or even other black holes which are undiscovered by the mainstream books.

The book published by the wonderful publisher Apress is an absolutely must-have!