Home Page Icon
Home Page
Table of Contents for
II. Techniques
Close
II. Techniques
by Paul Hyde
Java Thread Programming
Copyright
Dedication
About the Author
Acknowledgments
Tell Us What You Think!
Introduction
Structure of This Book
Chapter 1—"Introduction to Threads"
Chapter 2—"A Simple Two-Thread Example"
Chapter 3—"Creating and Starting a Thread"
Chapter 4—"Implementing Runnable Versus Extending Thread"
Chapter 5—"Gracefully Stopping Threads"
Chapter 6—"Thread Prioritization"
Chapter 7—"Concurrent Access to Objects and Variables"
Chapter 8—"Inter-thread Communication"
Chapter 9—"Threads and Swing"
Chapter 10—"Thread Groups"
Chapter 11—"Self-Running Objects"
Chapter 12—"Exception Callback"
Chapter 13—"Thread Pooling"
Chapter 14—"Waiting For the Full Timeout"
Chapter 15—"Breaking Out of a Blocked I/O State"
Chapter 16—"The SureStop Utility"
Chapter 17—"The BooleanLock Utility"
Chapter 18—"First-In-First-Out (FIFO) Queue"
Appendixes: The Thread API and The ThreadGroup API
Conventions Used in This Book
I. Threads
1. Introduction to Threads
What Is a Thread?
Why Use Multiple Threads?
Better Interaction with the User
Simulation of Simultaneous Activities
Exploitation of Multiple Processors
Do Other Things While Waiting for Slow I/O Operations
Simplify Object Modeling
When Multiple Threads Might Not Be Good
Java's Built-in Thread Support
Easy to Start, Tough to Master
2. A Simple Two-Thread Example
Extending the java.lang.Thread Class
Overriding the run() Method
Spawning a New Thread
Putting It All Together
Summary
3. Creating and Starting a Thread
Using Thread.currentThread()
Naming a Thread: getName() and setName()
Using getName()
Using setName()
Thread Constructors
Enlivening a Thread: start() and isAlive()
Using Thread.sleep()
Summary
4. Implementing Runnable Versus Extending Thread
Visual Timer Graphical Component
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
Summary
5. Gracefully Stopping Threads
Interrupting a Thread: interrupt()
Interrupting a Sleeping Thread
Pending Interrupts
Using isInterrupted()
Using Thread.interrupted()
Using InterruptedException
Suspending and Resuming Thread Execution
Using the Deprecated Methods suspend() and resume()
Suspending at a Bad Time
Suspending and Resuming Without Deprecated Methods
Stopping a Thread
Using the Deprecated Method stop()
An Alternative to stop()
The Best Replacement for stop(), suspend(), and resume()
Daemon Threads
Summary
6. Thread Prioritization
System Thread Priorities
Thread Priority Constants
Thread.MAX_PRIORITY
Thread.MIN_PRIORITY
Thread.NORM_PRIORITY
Determining the Current Priority: getPriority()
Changing the Priority of a Thread: setPriority()
When setPriority() Might Not Work
Thread States
Priorities and Scheduling
Voluntarily Relinquishing the Processor: Thread.yield()
Thread-Scheduling Scenarios
Scenario I: One High-Priority Thread Hogs Processor
Scenario II: All High-Priority Threads Hog Processor
Scenario III: All Threads Get Some Time on the Processor
Summary
7. Concurrent Access to Objects and Variables
volatile Member Variable Modifier
synchronized Method Modifier
Two Threads Simultaneously in the Same Method of One Object
One Thread at a Time
Two Threads, Two Objects
Avoiding Accidental Corruption of an Object
Deferring Access to an Object While It Is Inconsistent
synchronized Statement Block
Reducing the Time That the Lock Is Held
Locking an Object Other Than this
Safely Copying the Contents of a Vector into an Array
static synchronized Methods
Using the Class-Level Lock in a synchronized Statement
Synchronization and the Collections API
Wrapping Collections to Make Them synchronized
Safely Copying the Contents of a List into an Array
Safely Iterating Through the Elements of a Collection
Deadlocks
Deadlock Avoidance
Speeding Concurrent Access
Summary
8. Inter-thread Communication
The Need for Inter-thread Signaling
The Wait/Notify Mechanism
Minimal Wait/Notify
Typical Wait/Notify
Wait/Notify with synchronized Methods
Object API Used for Wait/Notify
notify()
notifyAll()
wait()
wait(long)
wait(long, int)
When to Use notifyAll() Instead of notify()
Missed Notification
MissedNotify
MissedNotifyFix
Early Notification
EarlyNotify
EarlyNotifyFix
CubbyHole Example
Using join() to Wait for a Thread to Die
join()
join(long)
join(long, int)
JoinDemo
Streaming Data Between Threads Using Pipes
PipedBytes
PipedCharacters
Using ThreadLocal and InheritableThreadLocal
ThreadLocal API
ThreadID
InheritableThreadLocal API
InheritableThreadID
Summary
9. Threads and Swing
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
Summary
10. Thread Groups
What Are Thread Groups?
Using getParent()
Finding the Subgroups of a Thread Group
Using the getThreadGroup() Method of Thread
Finding All the Threads in a Thread Group
Understanding Thread Group Security
Using setMaxPriority() and getMaxPriority()
Using interrupt()
Deprecated Methods: stop(), suspend(), and resume()
Class ThreadViewer
Summary
II. Techniques
11. Self-Running Objects
Simple Self-Running Class
Using an Inner Class to Hide run()
Additional Functionality to Consider
Example: Animated Images on a JComponent
Summary
12. Exception Callback
ExceptionListener Interface
Additional Methods to Support ExceptionListener
Summary
13. Thread Pooling
Benefits of Thread Pooling
Considerations and Costs of Thread Pooling
A Generic Thread Pool: ThreadPool
A Specialized Worker Thread Pool: HttpServer
Class HttpServer
Class HttpWorker
Sample Files to Be Served
Running HttpServer with 3 Workers
Running HttpServer with 10 Workers
Summary
14. Waiting for the Full Timeout
Accidentally Returning Early
Determining If wait() Should Be Invoked Again
A General-Purpose Wait-Until Pattern
Summary
15. Breaking Out of a Blocked I/O State
The read() Method Ignores Interrupts and Stop Requests
Closing a Stream to Break Out of the Blocked State
Class CalcServer and Breaking Out of a Blocked accept()
Class CalcWorker and Breaking Out of a Blocked read()
Class CalcClient
Output When Run
Throwing InterruptedIOException When Interrupted
Class ThreadedInputStream
Class BufferedThreadedInputStream
Using BufferedThreadedInputStream for Interruptible I/O
Summary
16. The SureStop Utility
Guidelines for Using SureStop
The SureStop Class
Peering Inside Using SureStopVerbose
Watching It Work with SureStopDemo
Summary
17. The BooleanLock Utility
Background
BooleanLock Class
Inter-Thread Signaling Using BooleanLock
Avoiding Blocking on synchronized
SyncBlock
InterruptibleSyncBlock
Noticing Brief Changes in Value Using TransitionDetector
Summary
18. First-In-First-Out (FIFO) Queue
How a FIFO Queue Works
Implementing a FIFO with an Array
Simple Implementation in Java: SimpleObjectFIFO
An Expanded FIFO Queue for Object References: ObjectFIFO
A FIFO Queue for Bytes: ByteFIFO
Summary
III. Appendixes
A. The Thread API
Member Variables
Thread.MAX_PRIORITY
Thread.MIN_PRIORITY
Thread.NORM_PRIORITY
Constructors
Thread(ThreadGroup, Runnable, String)
Thread(ThreadGroup, Runnable)
Thread(ThreadGroup, String)
Thread(Runnable, String)
Thread(Runnable)
Thread(String)
Thread()
static methods
Thread.activeCount()
Thread.currentThread()
Thread.dumpStack()
Thread.enumerate()
Thread.interrupted()
Thread.sleep(long)
Thread.sleep(long, int)
Thread.yield()
Instance Methods
checkAccess()
destroy()
getContextClassLoader()
getName()
getPriority()
getThreadGroup()
interrupt()
isAlive()
isDaemon()
isInterrupted()
join()
join(long)
join(long, int)
run()
setContextClassLoader(ClassLoader)
setDaemon(boolean)
setName(String)
setPriority(int)
start()
toString()
Deprecated Methods
countStackFrames()
resume()
stop()
stop(Throwable)
suspend()
B. The ThreadGroup API
Constructors
ThreadGroup(ThreadGroup, String)
ThreadGroup(String)
Instance Methods
activeCount()
activeGroupCount()
checkAccess()
destroy()
enumerate(Thread[], boolean)
enumerate(Thread[])
enumerate(ThreadGroup[], boolean)
enumerate(ThreadGroup[])
getMaxPriority()
getName()
getParent()
interrupt()
isDaemon()
isDestroyed()
list()
parentOf(ThreadGroup)
setDaemon(boolean)
setMaxPriority(int)
toString()
uncaughtException(Thread, Throwable)
Deprecated Methods
allowThreadSuspension(boolean)
resume()
stop()
suspend()
Search in book...
Toggle Font Controls
Playlists
Add To
Create new playlist
Name your new playlist
Playlist description (optional)
Cancel
Create playlist
Sign In
Email address
Password
Forgot Password?
Create account
Login
or
Continue with Facebook
Continue with Google
Sign Up
Full Name
Email address
Confirm Email Address
Password
Login
Create account
or
Continue with Facebook
Continue with Google
Prev
Previous Chapter
10. Thread Groups
Next
Next Chapter
11. Self-Running Objects
Part II. Techniques
Add Highlight
No Comment
..................Content has been hidden....................
You can't read the all page of ebook, please click
here
login for view all page.
Day Mode
Cloud Mode
Night Mode
Reset