Customer Reviews

Java Thread Programming

5 star:		(24)
4 star:		(3)
3 star:		(0)
2 star:		(1)
1 star:		(0)

 

 

I just wanted to express my sincerest appreciation for this book. It has really helped me build a solid foundation of threading in Java.

The examples are easy to follow and the way that the author refers to the code line numbers in the text is very helpful. Concepts that I never quite grasped were explained in such a simple manner that I was left thinking "It's so easy! Why did I have trouble understanding this before!?".

I wanted to point out a few sections of the book that were especially helpful:

1) Synchronized Statement Block (pg 144-146). I have attained my Java certification at the programmer level, so I already knew how to use the synchronized keyword as method modifiers and in blocks. However, this section of the book really cleared up the concept of what it actually means to get a synchronized lock on an object. This line, on page 144, made it all clear: "... obj is a reference to the object whose object-level lock must be acquired before entering the block of code."

2) I can't find the page number, but the book makes a reference to the point that when two threads are running you can't be sure when the thread scheduler will remove it from the running state and place another thread into the running state. This really helped me understand how multi-threading programs work in general. Instead of talking about threads as slices of time (as some texts do), it was much easier to understand the concept of the almighty thread scheduler taking individual threads on or off the running state and that when they would be placed back into the running state, they would continue from where they left off before.

3) Deadlocks (pp 160-165). I have heard of this situation before but never really understood how a situation like this could arise. The diagram on page 161 and sample program on page 161 really brought the point home.

4) The Wait/Notify Mechanism (pp 168). The example on page 169 helped me understand why wait( ), notify( ), and notifyAll( ) are part of the Object class. I often wondered why these methods weren't part of the Thread class. This entire chapter was a pleasure to read because it clearly explained how wait and notify work and how they should to be used. The timing diagrams were also very helpful.

5) Threads and Swing (Chapter 9). The motivation example (page 232) for why it is sometimes necessary to create a new thread in a Swing application really helped me get a better understanding of the event dispatching thread. This made it very easy to understand SwingUtilities.invokeAndWait( ) and SwingUtilities.invokeLater( ).

I have a few suggestions for future editions of the book. The first suggestion is for providing exercises at the end of each chapter. Or perhaps there could be a Part 3 to the book which lists multi-threaded programming projects that readers can try. For example, I wrote the CubbyHole program on page 192 by myself, before looking at the code in the book. The second suggestion is to have more information about debugging in multi-threaded programs. A listing of the techniques as well as the common tools used would be most helpful. The third suggestion is to provide some examples when you would use ThreadLocal and InheritableThreadLocal in the real world.

Thank you, Mr. Hyde, for writing such a beautiful book!

Paul does an extremely good job of explaining threads. Even
though I haven't yet completed the book, I have already gotten
my moneys worth out of it.
.
It has been quite awhile since I looked into threads. I've had
little opportunity to use them, and none in Java. So, I was
quite pleased to see the number of very positive comments about
this book. I have yet to understand the harsh rating by Dan.
.
I bought this book (mainly because of the number of good
reviews) because I had a problem I was trying to solve. Since
getting the book, I've worked my way through 8 chapters, and
have greatly enjoyed reading the material, as well as having
learned/relearned a vast amount about Java threads.
.
Pros:
- Excellent writing style
- Very few (as far as I can tell anyway ;-) errors
- Use of a variety of example styles to demonstrate thread
relationships, and timings - these make for much better
comprehension of the material.
.
Cons: (nothing significant)
- End of section/chapter exercises could be of benefit.

I was studying for the SJCP exam. I had every certification book in the house. However, none of the certification books were covering threads in a coherent manner that allowed me to master the threading part of the exam. This book did. I went from scratching my head at why I missed a thread question in the 100's of practice certification exams to scoring 100's in the thread section of the exams. For those of you that are doing your certification, get this book to supplement the exam guides.

Another outstanding Sam's title. The progression of concepts in Java Thread Programming is very clear and the example code is great. I found Hyde's progressive build up of small example applications particularly useful. That's how it happens in real life!

I think this is a better book for beginners than the O'Reilly Java Thread's book. The O'Reilly book tends to quickly pile through each concept while the Sam's book takes a more leisurely approach. The O'Reilly book also occasionally goes off on tangents. Hyde's book, however, points out potential sources of trouble while taking an easy to follow, serial thread to understanding asynchronous programming in Java.

Threads are a tricky business and while Java makes their use easier there are still lots of pitfalls and gotchas. This is the first book I've found with solid examples that have already helped me solve some problems I am working on. Other books, while sometimes good (Lea's book comes to mind) are more theory and less example based than I like. This book on the other hand, is full of useful examples. Highly recommended, although getting the source code should be easier for non windows users. If you have trouble email the author. He was very helpful when I dropped him a note.

Very straightforward and gentle introduction to the Java threading mechanics.It features basic theory and examples for about 3/4 of the book with the rest of the pages dedicated to a few useful techniques to ease and streamline threads programming, which you can use in you applications or as inspiration and examples for your own devices. My only complaint is the presentation method: a bunch of code followed by a bunch of explanations. I think presenting the more relevant lines of code interleaved with explanations and then the whole example program would make learning much more effective and easy. This book is also starting to show its age, so until a second edition comes out I would recommend the O'Reilly book over this one, unless you can get it real cheap.

I used this book as a reference in building threaded HTTP
and SOAP output queues for a very time critical project.
The book is clearly written, with good Java examples. I did
not have time to spend a week reading a book and working
through the examples. This book provided what I needed most:
a clear introduction that was well organized.

This book is published by SAMS. Not only is the content good,
but they layout and structure are good as well. This is a huge
improvement over the SAMS books that were printed back in the
days of Windows 3.1 and DOS.

I bought this book purely to understand how the notify()/wait() system works in Java and how I could use it for network server threads. I now have working software so for that reason alone it was a great buy!

It's an easy to read book with quite good examples. However, my main issue was that I wanted a "cookbook" with ready to use and well written code samples. Instead, this book is written for people who learn sequentially by reading from the front of the book to the back. So a lot of the code samples are actually examples of code that is deficient for some reason and then the following code is an example of how the deficiency was mitigated. This isn't bad if you read the book from start to finish but if you want to dive in, grab a code snippet of something that'll work, and work well, you have to root around a bit to find the final example.

Java Thread Programming is by far the best treatment of this subject in the marketplace. I have found that the structure, code samples, and reference very handy. Paul Hyde is a very easy to understand writing artist. His approach is informational and practical. This book is for the experienced Java developers who would like to learn, and revisit threads from a more thorough standpoint. Therefore, I highly recommend this book to all serious Java developers.

This is a particularly easy to understand book on Java threads. If you are new to Java or to threading then don't hesitate to buy this book. The topics are clearly explained and in a logical order. The examples are small enough that they are easy to understand, but big enough to get the point across. And they work! Mr. Hyde has clearly gone to a great amount of trouble to make his presentation clear and simple to digest. As examples the diagrams he presents for explaining a deadlock and the timing of events in a wait/notify sequence make what is going on very clear.

If you are an experienced thread programmer looking for the finer points of threading, this book might not be the best. It does not go into the level of detail that some other books do, for example Holub's book "Taming Java Threads". On the other hand, these books are not the best for beginners.