Customer Reviews

Java Threads, Second Edition

5 star:		(14)
4 star:		(10)
3 star:		(3)
2 star:		(5)
1 star:		(9)

 

 

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.

This isn't the best O'Reilly book in the Java series, but it will provide a reasonably good overview of the subject. I wouldn't recommend this book to beginning programmers, because the topic of threading is overly complex for beginners. Look for a general Java book that gives you some simple templates for using threads, if you need them for something. I also wouldn't recommend this for advanced programmers who have special needs in the area of threading. A more advanced book would survey how real JVMs actually perform thread scheduling, comparing them and provide tips for programmers who ned really precise timing or scheduling optimization. Likewise, if you know most of the ins and outs of preventing deadlocks off the top of your head, this book isn't going to teach you very much.

Who this book is good for is experienced programmers who need to understand the ins and outs of making their applications threadsafe. If you don't have much (or any) background in threading or you've forgotten some things, this book will cover the topic thoroughly, and demonstrate common pitfalls. It's ideal for people who need to code up things like database connection pools, complex synchronized-access data structures, and statically-accessed resources. As others have mentioned, some of the examples are kind of synthetic and fake, but the book is still extremely usable, and it's an easy read.

This book is also effective at covering timed and recurring tasks in Java 1.1 and 1.2, though Java 1.3 now has new helper classes (Timer and TimedTask) that this book doesn't cover. Then again, if you understand how to do it in 1.1 and 1.2 (and really, even if you don't), understanding the new 1.3 classes is dead easy.

This book is not academic, nor does it offer a very rigorous approach to the subject of Concurrent Programming. This book will not work for everyone. However, I believe it does offer basic, solid threading to many new people for most everyday programming tasks.

Threading is not an incredibly difficult or complex topic. Threading is an advanced programming topic. Solid programming knowledge is prerequiste.

If you already are proficient in writing threaded code in other languages, I would not recommend (buying) this book. Simply reading the interface for Thread and Runnable may suffice. Java's threading support is quite elegant; you shouldn't have major problems figuring things out.

Threading is kind of confusing at first because it involves calling procedures for the sole purpose of timing. That is, a correctly written program will use a set of procedures in such a way that when a call returns, it will be safe to access shared data.

This book is not concise as it could be, but if you are a reasonably experienced and intellegent programmer, you should be able to handle most basic sychronization tasks after reading this book. It is written in style that goes like this:

1. It introduces a problem.

2. It briefly shows a solution a student might suggest.

3. It then explains why this doesn't work.

4. It finally explains the proper solution.

You need to understand why something is correct or not, not only how to do it correctly. Whether or not you like the particular approach used in this book is a matter of personal preference.

After reading this book, I would recommend a good textbook on concurrent programming to further and more rigorously study issues of sychronization, starvation, control, and deadlock.

It not only covers the threads API, it also covers how they work and advanced tricks to using them.

The problem which most of the threading material related to Java I've read in other books has contained errors. "Java Threads" as well as Doug Lea's "Concurrent Programming in Java" are the only accurate books that I know of although their focus is very different. Another good thing about this book is that it has much otherwise hard to find information about how threads actually work in Java.

I highly recommend this book to anytone working with Java threads. I'm sure you will find information in here that you previously didn't know.

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.

The second edition clearly distinguishes between Java 2 and previous versions, and includes valuable information about the differences between Java VM's and how to code around them in a portable way. The explanation of how to safely stop a thread should be useful. Could be improved by more information about the performance of Java VM's under heavy load.

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.

The sub-title of this book is Understanding and Mastering Concurrent Programming and I think that this pretty well sums up what it's all about. In perhaps its simplest and most obvious task consider a word processing system. Periodically you want to save what you've typed. So you hit Control-S or whatever, and then you wait until the save is completed before you can continue typing. If the save routine and the data input routine were written using threads, both could run at once and you wouldn't have to wait to continue typing. That's a pretty trivial example compared to something like a web server where you get a request, prepare a page to be displayed and then send it out to the browser that made the request. If this had to be done sequentially, the resulting server would be slow; very, very slow. And since most communications channels are so much slower than the processor, you'd best have several threads running just to handle the transmission of the page.

These are simple to understand threads. And the first one, saving and typing are fairly simple to program. To get suitable performance out of a web server, you want some pretty good programmers. No one is going to claim that programming in threads is the easiest kind of program to write. But it can be argued that programming threads in Java is easier than just about any programming language. This is especially true with the additions made in Java 2 Standard Edition Version 5.0 (J2SE 5.0).

This book is not intended to be your first Java book. You need to know the Java syntax, philosophies, and have some experience in programming. But having said that, most of the Java programming books skip over threads or treat them very superfically. This book picks up where those books leave off. It's intended for the intermediate level programmer up to advanced. And it's an O'Reilly book, they don't do bad stuff.

This is a prettry decent book on threads, but I frankly found it to be a little flat. The writing doesn't exactly pop and it is a pretty small book. I think they could easily write a book about twice the size and cover the topic entirely.
However, if you are new to multithreading, or at least new to Java threads, this is a great intorduction to the subject. And it is very difficult to find a lot of information on Java threads anyway, which is why I bought this book in the first place. There are some very practical code examples too, including a round robin scheduler.

<< Review of the 3rd Edition >>

This book is written for developers who are targeting the second wave of java programs - Intermediate to advanced level programmers will be able to get best value out of this book. Developers who are already familiar with the basics of java may also be able to get some value, but if you are completely new to java, please look elsewhere.

Without any futher ado, i will dive right into the deep end of the pool. This book is partitioned into 4 logical sections, though it is not explicit in the TOC.

1. Important Threading Concepts:
In this section, the author prepares us with the fundamentals of creating and managing a thread, basic synchronization concepts, synchronized keyword, lock mechanism, thread communication using wait-notify and condition-variables, minimal synchronization using volatile keyword and atomic variables, advanced synchronization classes like Barrier, Semaphore, CountdownLatch, etc. Chapters 1 through 6 underwrite this section and this is by-far the best part of the book.

2. Thread Pools/Schedulers:
This section first lectures around how thread scheduling materializes in java and how it is related to the underlying Operating System. Next, you are guided through a tour of Thread Pools and Task Schedulers that will enlighten us with quite a few new classes in java 5. Chapters 9 through 11 cover this section.

3. Threading and other Java APIs:
This section details how the threading API plays with other inbuilt java APIs like Collections, IO and Swing. Chapters 7,8 and 12 cover this section.

4. Misc topics:
Some miscellaneous thread topics like ThreadGroup, Security, Class Loading, Exception Handling and Performance are addressed in this section. Chapters 13, 14, and 15 cover this section.

Though this book wasn't an easy read, i found it extremely encouraging to have ONE comprehensive manual to understand both the threading concepts and the new java 5 inclusions. I recommend this book to anyone who is in the middle of a complex multi-threaded system or wishes to create one.