Threads are essential to Java programming, but learning to use them effectively is a nontrivial task. This new edition of the classic Java Threads shows you how to take full advantage of Java's threading facilities and brings you up-to-date with the watershed changes in Java 2 Standard Edition version 5.0 (J2SE 5.0). It provides a thorough, step-by-step approach to threads programming.Java's threading system is simple relative to other threading systems. In earlier versions of Java, this simplicity came with tradeoffs: some of the advanced features in other threading systems were not available in Java. J2SE 5.0 changes all that: it provides a large number of new thread-related classes that make the task of writing multithreaded programs that much easier.You'll learn where to use threads to increase efficiency, how to use them effectively, and how to avoid common mistakes. This book discusses problems like deadlock, race conditions, and starvation in detail, helping you to write code without hidden bugs.Java Threads, Third Edition, has been thoroughly expanded and revised. It incorporates the concurrency utilities from java.util.concurrent throughout. New chapters cover thread performance, using threads with Swing, threads and Collection classes, thread pools, and threads and I/O (traditional, new, and interrupted). Developers who cannot yet deploy J2SE 5.0 can use thread utilities provided in the Appendix to achieve similar functionality with earlier versions of Java.Topics include:
Lock starvation and deadlock detection
Atomic classes and minimal synchronization (J2SE 5.0)
Interaction of Java threads with Swing, I/O, and Collection classes
Programmatically controlled locks and condition variables (J2SE 5.0)
Thread performance and security
Thread pools (J2SE 5.0)
Platform-specific thread scheduling
Task schedulers (J2SE 5.0)
Parallelizing loops for multiprocessor machines
In short, this new edition of Java Threads covers everything you need to know about threads, from the simplest animation program to the most complex applications. If you plan to do any serious work in Java, you will find this book invaluable.Scott Oaks is a senior software engineer for the Java Performance Engineering group at Sun Microsystems and the author of four books in the O'Reilly Java series.Formerly a senior systems engineer at Sun Microsystems, Henry Wong is an independent consultant working on various Java related projects.
Chapter 1 Introduction to Threads
About the Examples
Chapter 2 Thread Creation and Management
What Is a Thread?
Creating a Thread
The Lifecycle of a Thread
Two Approaches to Stopping a Thread
The Runnable Interface
Threads and Objects
Chapter 3 Data Synchronization
The Synchronized Keyword
The Volatile Keyword
More on Race Conditions
Choosing a Locking Mechanism
Chapter 4 Thread Notification
Wait and Notify
Chapter 5 Minimal Synchronization Techniques
Can You Avoid Synchronization?
Thread Local Variables
Chapter 6 Advanced Synchronization Topics
Synchronization Classes Added in J2SE 5.0
Chapter 7 Threads and Swing
Swing Threading Restrictions
Processing on the Event-Dispatching Thread
Using invokeLater( ) and invokeAndWait( )
Long-Running Event Callbacks
Chapter 8 Threads and Collection Classes
Overview of Collection Classes
Synchronization and Collection Classes
The Producer/Consumer Pattern
Using the Collection Classes
Chapter 9 Thread Scheduling
An Overview of Thread Scheduling
Scheduling with Thread Priorities
Popular Threading Implementations
Chapter 10 Thread Pools
Why Thread Pools?
Using a Thread Pool
Queues and Sizes
Callable Tasks and Future Results
Chapter 11 Task Scheduling
Overview of Task Scheduling
The java.util.Timer Class
The javax.swing.Timer Class
The ScheduledThreadPoolExecutor Class
Chapter 12 Threads and I/O
A Traditional I/O Server
A New I/O Server
Chapter 13 Miscellaneous Thread Topics
Threads and Java Security
Threads and Class Loading
Threads and Exception Handling
Threads, Stacks, and Memory Usage
Chapter 14 Thread Performance
Overview of Performance
Atomic Variables and Contended Synchronization
Thread Creation and Thread Pools
Chapter 15 Parallelizing Loops for Multiprocessor Machines
Scott Oaks is a Java Technologist at Sun Microsystems, where he has worked since 1987. While at Sun, he has specialized in many disparate technologies, from the SunOS kernel to network programming and RPCs. Since 1995, he's focused primarily on Java and bringing Java technology to end-users. Scott also authored O'Reilly's Java Security, Java Threads and Jini in a Nutshell titles.
Henry Wong is an independent consultant, involved in various Java related projects. Henry previously workedas a computer engineer at Sun Microsystems from 1989to 2003. Originally hired as a consultant to help customers with special device drivers, kernel modifications, and DOS interoperability products, Henry has also worked on Solaris ports, performance tuning projects, and multithreaded design and implementations for benchmarks and demos. Since early 1995, Henry has been involved in developing Java prototypes and supporting customers who are usingJava.
Prior to working at Sun, Henry earned a Bachelor of Science degree in chemical engineering from The Cooper Union in 1987. He joined a small software company in 1986 working on SCSI device drivers, image and audio data compression, and graphics tools used for a medical information system.
When not in front of a computer, Henry is an instrument rated private pilot, who also likes to dabble in archery, cooking, and traveling to different places with his wife, Nini.
Our look is the result of reader comments, our own experimentation, and feedback from distribution channels. Distinctive covers complement our distinctive approach to technical topics, breathing personality and life into potentially dry subjects. The animal on the cover of Java Threads, Third Edition is a marine invertebrate. Invertebrates, or animals without backbones, make up over 97 percent of all animal species on the planet. Marine invertebrates are abundant in every ocean, and include such diverse species as crabs, sea cucumbers, jellyfish, starfish, urchins, anemones, and shrimps. One of the most intelligent animals in the sea, the octopus, is also an invertebrate.Many invertebrates have protective shells to shield them from hungry, razor-toothed predators. You may think that invertebrates without shells would be particularly vulnerable,but many have developed some effective defenses. Sea anemones brandish tentacles that sting their enemies,urchins have sharp spikes that cover their entire bodies, and sea slugs just don't taste very good.Though you may not realize it, marine invertebrates are quite beneficial to humans. For one, they constitute a huge food source. Shrimps, crabs, octopuses, clams, oysters, squids, lobsters, scallops, and crayfish are all tasty delicacies. Invertebrates are also nature's vacuum cleaners, taking in dead and discarded material and recycling it through the food chain. And after millions of years, the bodies of invertebrates settle on the sea floor and form oil deposits, a major source of the world's energy. Matt Hutchinson was the production editor for Java Threads, Third Edition. Octal Publishing, Inc. provided production services. Sarah Sherman, Marlowe Shaeffer, and Claire Cloutier provided quality control.Emma Colby designed the cover of this book, based on a series design by Edie Freedman. The cover image is a 19th-century engraving from the Dover Pictorial Archive. Emma Colby produced the cover layout with QuarkXPress 4.1 using Adobe's ITC Garamond font.David Futato designed the interior layout. This book was converted by Joe Wizda to FrameMaker 5.5.6 with a format conversion tool created by Erik Ray, Jason McIntosh, Neil Walls, and Mike Sierra that uses Perl and XML technologies. The text font is Linotype Birka; the heading font is Adobe Myriad Condensed; and the code font is LucasFont's TheSans Mono Condensed. The illustrations that appear in the book were produced by Robert Romano and Jessamyn Read using Macromedia FreeHand 9 and Adobe Photoshop 6. This colophon was written by Matt Hutchinson.
One of the best things about this book is although this book was published in 2004, in my opinion it is still one of THE BEST books one can read on Java Threads.
For beginners like me, understanding multi-threading concepts is not really easy. But this book made them easy for me.
The book teaches you how to visualize the underlying concepts. The examples very clearly explain the concepts and are followed by authors' explanation ( the second best thing about this book ).
I know I'm reading this book in 2013 and there are new additions in the newer Java versions but this book covers the advanced concepts introduced with J2SE 5.0 so well that I am not missing much. Whatever little needs to be known, I will be able to understand it from the API docs- thanks to such great explanation of the foundation to advanced concepts in the book. Having said that, if the authors decide to come up with another edition of the book, I will buy that too cause I know it'll be worth it.
The first time I bought this book, I bought it from a local library. As I began reading this book, I realized I should have my own copy of it and I ordered it the same day. I'm glad I did so.
Not sure who, but some wise person said- if something can be read without effort, great effort has gone into its writing. I appreciate all the effort that has gone into the making of Java Threads Edition 3. Thank you, Scott Oaks and Henry Wong.
Bottom Line Yes, I would recommend this to a friend
I happen not to agree with the previous review, everything is clearly explained in the book. For instance, p40, a lock is explained as:
When a method is declared synchronized, the thread that wants to execute it must acquire a token, which we call a lock (...) Only one thread can grab a lock at a time (...) Upon completion of the method, the lock is automatically released.
Sure, the thread topic is not for beginners, but since every program is going to use threads whether you want it or not, any self-respecting programmer should have a good knowledge of threads.
This book also covers all the new thread-related class of Java 5.0, which is the reason why I bought it.
Very poor book. Many essential explanations are missing, possibly due in part to an apparent obsession with race conditions. Although race conditions are a very important topic, and they should be thoroughly covered in a book such as this, many of them can be avoided by knowing the basics, which this book does not explain well.
For instance, look at lock() and unlock(). What is being locked? What is being unlocked? Basic questions, right? We are never really told. Although there is much text devoted to these methods, it is left to the reader to figure out the answer to these questions.
The same is true for wait() and notify(). What is being waited on? Who is being notified? We are never really told, but rather we are left to try to put the descriptions together in a way that makes sense.
There are many other areas of total confusion (including many pages devoted to a "race condition" that apparently does not exist), but the above examples should give you an idea of the caliber of this book.