Taming Java Threads [Paperback]

Allen Holub (Author)

Book Description

Publication Date: June 2, 2000

Learning how to write multithreaded applications is the key to taking full advantage of the Java platform. In Taming Java Threads, well-known columnist and Java expert Allen Holub provides Java programmers with the information they need to write real multithreaded programsprograms with real code. Holub provides an in-depth explanation of how threads work along with information about how to solve common problems such as deadlocks and race conditions. He not only explains common problems, but also provides the uncommon solutions that mark the difference between production-level code and toy demos.

While it is essential to build support for threading into a Java program from the very beginning, most books on the subjects of Java user interface construction and Java networking barely touch on threading topics. Along with being a basic Java reference, this book is a must-read for any Java developer.

What you’ll learn

• The architecture of threads
• The mutex and lock management
• Condition variables and counting semaphores
• Timers, alarms and swing thread safety
• Observers and multicasters
• Singletons, critical sessions, and reader/writer locks
• Threads in an object-oriented world
• Object-oriented threading architectures

Who this book is for

All Java developers.

Editorial Reviews

From the Author

Allen Holub is a design consultant, programmer, educator and author specializing in Object-Oriented Design, Java, C++, and systems programming. A recognized authority in Java programming, he has worked in the computer field since 1979 and was an early adopter of Java - programming in it since 1995. At the time of this publication, Holub is a contributing editor for JavaWorld, and he is a popular columnist appearing in many computer magazines including: Dr. Dobb's Journal, Microsoft Systems Journal, Programmers Journal, BYTE, Windows Tech Journal, Mac Tech Journal, and C Gazette.

About the Author

Allen Holub is a design consultant, programmer, educator, and author specializing in object-oriented design, Java, C++, and systems programming. He is a contributing editor for JavaWorld, and a popular columnist appearing in many computer magazines, including Dr. Dobb's Journal and Microsoft Systems Journal.

Product Details

• Paperback: 300 pages
• Publisher: Apress (June 2, 2000)
• Language: English
• ISBN-10: 1893115100
• ISBN-13: 978-1893115101
• Product Dimensions: 9.3 x 7.4 x 0.8 inches
• Shipping Weight: 1.4 pounds (View shipping rates and policies)
• Average Customer Review: 3.7 out of 5 stars  See all reviews (15 customer reviews)
• Amazon Best Sellers Rank: #1,228,968 in Books (See Top 100 in Books)

Customer Reviews

Most Helpful Customer Reviews

17 of 19 people found the following review helpful:

5.0 out of 5 stars All meat, no potatos..., June 10, 2000

By A Customer

This review is from: Taming Java Threads (Paperback)

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.

13 of 14 people found the following review helpful:

3.0 out of 5 stars Assumes you know about threads already, December 1, 2003

By A Customer

This review is from: Taming Java Threads (Paperback)

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

8 of 8 people found the following review helpful:

4.0 out of 5 stars Read Another Thread Book First, October 1, 2003

By 

grandpiano_57 "James" (Burlington, CT USA) - See all my reviews

This review is from: Taming Java Threads (Paperback)

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.