Java Thread Programming

a book by Paul Hyde

Buy it: [ISBN: 0672315858]

Table of Contents
Key Topics
About the Author
Download the Source Code
Errata
Customer Reviews on Amazon.com

One of the great features of Sun Microsystems' Java programming language is that is has built-in support for multithreaded programming. This book is for those of you who have started working with Java and have realized that you want to develop multithreaded applications and applets. It's easy to get started with threads, but their safe and proper use is tough to master. Java Thread Programming starts by demonstrating the basics of threads and moves on to advanced multithreaded concepts. This comprehensive book covers all thread-related issues in Java (including changes in Java 2) and shows how to write multithread-safe code.
Key topics:

Start by learning the basics of multithreaded programming in Java, and work up to the more advanced concepts.
Suitable tutorial for Java developers that have never worked with threads before, and an excellent reference and source of proven, advanced techniques for Java developers who have had experience working with threads.
Explains how `volatile` and `synchronized` should be used to control concurrent access to objects and variables and how to avoid deadlocks.
Discusses how to implement safe and efficient inter-thread communication using the wait-notify mechanism.
Explains how thread prioritization and scheduling affect the execution of threads within an application.
Discusses pros and cons to different approaches and teaches you how to choose the best solutions.
Covers the proper use of threads and Swing, and shows how to use threads to create animation.
Shows you how to use the Collections API in a thread-safe manner.
Comprehensively covers multithreaded code based on JDK 1.2 (Java 2) and discusses the differences from JDK 1.1 and JDK 1.0.
Includes advanced techniques that demonstrate how to create self-running objects, how to create a simple Web page server that uses thread pooling, how to break out of blocked I/O statements, and how to build a multithreaded First-In-First-Out (FIFO) queue.
Covers the complete API for `Thread`, `ThreadGroup`, `ThreadLocal`, and `InheritableThreadLocal`.
Includes ready-to-run examples --over 8,000 lines of Java code in over 100 complete classes.

Table of Contents:

Introduction
Part I - Threads

    1 - Introduction to Threads
    2 - Simple Two-Thread Example
    3 - Creating and Starting a Thread
    4 - Implementing `Runnable` versus
          Extending `Thread`
    5 - Gracefully Stopping Threads
    6 - Thread Prioritization
    7 - Concurrent Access to Objects
          and Variables
    8 - Inter-thread Communication
    9 - Threads and Swing
   10 - Thread Groups

Part II - Techniques

   11 - Self-running Objects
   12 - Exception Callback
   13 - Thread Pooling
   14 - Waiting For the Full Timeout
   15 - Breaking Out of a Blocked I/O State
   16 - `SureStop` Utility
   17 - `BooleanLock` Utility
   18 - First-In-First-Out (FIFO) Queue

Part III - Appendices

    A - `Thread` API
    B - `ThreadGroup` API

Index

Introduction
Part I - Threads - (276 pages)

Chapter 1 - Introduction to Threads - (8 pages)

What is a thread?
Why use multiple threads?
When multiple threads might not be good
Java's built-in thread support
Easy to get started, tough to master

Chapter 2 - Simple Two-Thread Example- (8 pages)

Extending the `java.lang.Thread` class
Overriding the `run()` method
Spawning a new thread
Putting it all together

Chapter 3 - Creating and Starting a Thread- (16 pages)

Using `Thread.currentThread()`
Naming a thread: `setName()` and `getName()`
Thread constructors
Enlivening a thread: `start()` and `isAlive()`
Using `Thread.sleep()`

Chapter 4 - Implementing `Runnable` versus Extending `Thread`- (26 pages)

Visual timer graphical component: `SecondCounter`
Extending `Thread` and `JComponent`?
Interface `java.lang.Runnable`
Passing a `Runnable` object to a `Thread`'s constructor
Modifying `SecondCounter` to use `Runnable`
Checking the accuracy of `SecondCounter`
Improving the accuracy of `SecondCounter`

Chapter 5 - Gracefully Stopping Threads- (36 pages)

Interrupting a thread: `interrupt()`
Suspending and resuming thread execution
Stopping a thread
Best replacement for `stop()`, `suspend()`, and `resume`
Daemon threads

Chapter 6 - Thread Prioritization- (20 pages)

System thread priorities
Thread priority constants
Determining the current priority: `getPriority()`
Changing the priority of a thread: `setPriority()`
Thread states
Priorities and scheduling
Voluntarily relinquishing the processor: `Thread.yield()`
Thread scheduling scenarios

Chapter 7 - Concurrent Access to Objects and Variables - (46 pages)

`volatile` member variable modifier
`synchronized` method modifier
`synchronized` statement block
`static synchronized` methods
Using the class-level lock in a `synchronized` block
Synchronization and the Collections API
Deadlocks
Deadlock avoidance
Speeding concurrent access

Chapter 8 - Inter-thread Communication - (54 pages)

The need for inter-thread signaling
The wait-notify mechanism
`Object` API used for wait-notify
When to use `notifyAll()` instead of `notify()`
Missed notification
Early notification
`CubbyHole` example
Using `join()` to wait for a thread to die
Streaming data between threads using pipes
Using `ThreadLocal` and `InheritableThreadLocal`

Chapter 9 - Threads and Swing - (44 pages)

Why isn't the Swing toolkit multithread-safe?
Using `SwingUtilities.invokeAndWait()`
Using `SwingUtilities.invokeLater()`
Using `SwingUtilities.isEventDispatchThread()`
When `invokeAndWait()` and `invokeLater()` are not needed
The need for worker threads in a GUI setting
Using a worker thread to relieve the event thread
Scrolling text in a custom component
Animating a set of images
Displaying elapsed time on a `JLabel`
Floating components around inside a container

Chapter 10 - Thread Groups - (16 pages)

What are thread groups?
Using the `getThreadGroup()` method of `Thread`
Understanding thread group security
Using `setMaxPriority()`
Using `interrupt()`
Deprecated: `stop()`, `suspend()`, and `resume()`
Using `getParent()`
Using `activeCount()`
Class `ThreadViewer`

Part II - Techniques - (186 pages)

Chapter 11 - Self-running Objects - (14 pages)

Simple self-running class
Using an inner-class to hide `run()`
Additional functionality to consider
Example: animated images on a `JComponent`

Chapter 12 - Exception Callback - (10 pages)

`ExceptionListener` interface
Additional methods to support `ExceptionListener`

Chapter 13 - Thread Pooling - (34 pages)

Benefits of thread pooling
Considerations and costs of thread pooling
Generic thread pool: `ThreadPool`
Specialized worker thread pool: `HttpServer`

Chapter 14 - Waiting For the Full Timeout - (16 pages)

Accidentally returning early
Determining if `wait()` should be invoked again
A general purpose wait-until pattern

Chapter 15 - Breaking Out of a Blocked I/O State - (30 pages)

The `read()` method ignores interrupts and stop requests
Closing a stream to break out of the blocked state
Throwing `InterruptedException` when interrupted
Using `BufferedThreadedInputStream` for interruptible I/O

Chapter 16 - `SureStop` Utility - (20 pages)

Guidelines for using `SureStop`
`SureStop` class
Peering inside using `SureStopVerbose`
Watching it work with `SureStopDemo`

Chapter 17 - `BooleanLock` Utility - (22 pages)

Background
`BooleanLock` class
Inter-thread signaling using `BooleanLock`
Avoiding blocking on `synchronized`

Chapter 18 - First-In-First-Out (FIFO) Queue - (38 pages)

How a FIFO queue works
Implementing a FIFO with an array
Simple implementation in Java: `SimpleObjectFIFO`
Expanded FIFO queue for object references: `ObjectFIFO`
FIFO queue for bytes: `ByteFIFO`

Part III - Appendices

Appendix A - `Thread` API - (12 pages)

Member variables
Constructors
`static` methods
Instance methods
Deprecated methods

Appendix B - `ThreadGroup` API - (8 pages)

Constructors
Instance methods
Deprecated methods

Index

About the Author:

Paul Hyde - Java Expert
[ email Paul ]

Resume Summary: [ full resume ] Paul Hyde

8.5 years of intensive Java-specific experience!
14 years of professional software development experience.
Author of the book: Java Thread Programming.
Sun Certified Web Component Developer for J2EE.
Sun Certified Programmer for the Java 2 Platform 1.4.
9 years of part-time (evening) and some full-time teaching experience.
Developed curricula and taught Java I, Java II, Core Java, JDBC, Threads, XML, Servlets/JSP, EJB, Java Web Start, Swing, UML, Object Oriented Design Patterns, and HTML training classes.
Author of SimpleServlets open-source library.
Author of ProgramixGenericLib open-source library.
7.5 years as President and Senior Consultant for Programix Incorporated.
Master of Science in Computer Science.
Bachelor of Science in Electrical Engineering.

SOURCE CODE:

There are instructions in the "Introduction" (page 1) of the book for downloading the source code from Sams Publishing, but these instructions may not work exactly as written due to re-organization of the samspublishing.com site. For your convenience, the code is available below. This source code is only for use by people who have purchased a copy of Java Thread Programming.

`JavaThreadProgrammingCode.zip` [109 kB; All classes now in packages (line numbers have changed slightly); Eclipse Project Ready]

`JavaThreadProgramming_src.zip` [100 kB; Exactly matching book—no packages]

`JavaThreadProgramming_src.tar.gz` [44 kB; Exactly matching book—no packages]

Download from samspublishing.com

ERRATA:

page 34 - [ccc]: Lines 19 and 21 have a funny symbol "[ccc]" which should have been replaced by a continuation line arrow (see page 44, line 56 for an example) by the copy editor. The [ccc] text should be completely ignored. The downloadable source code does not have this typo.
page 175 - wait(long, int): Middle paragraph refers to wait(long, int) and should instead point readers at wait(long).

Click here to buy: Java Thread Programming

[ Programix Home ]