Index

A

accessing threads, Thread Access, Enumerating Threads in the Virtual Machine
AccessNative class (example), Explicit synchronization and native code
Account class (example), A Banking Example, A Class to Perform Synchronization, Return to the Banking Example
active threads, Enumerating Threads in the Virtual Machine, A Network Server Class , Enumerating Thread Groups
activeCount() (Thread), Enumerating Threads in the Virtual Machine, Enumerating Thread Groups
activeGroupCount() (ThreadGroup), Enumerating Thread Groups
add() (ThreadPool), Thread Pools
addItems() (ArrayTest; example), Explicit Synchronization
addRequest() (ThreadPool), Thread Pools
addRequestAndWait() (ThreadPool), Thread Pools
alarms, Alarms and Timers
algorithms, parallelizable, Parallelizable Algorithms
allowThreadSuspension() (ThreadGroup), Miscellaneous Methods
analysis of loops, Loop Analysis and Transformations, Loop reimplementation
loop distribution, Loop distribution
loop isolation, Loop isolation
reimplementing loops, Loop reimplementation
Animate applet (example), Animate Applet, Threading Using the Runnable Interface, The isAlive() Method, The isAlive() Method, Enumerating Threads in the Virtual Machine, More on Starting, Stopping, and Joining
animation, Animate Applet, When to Use Simple Priority-Based Calls
animation, Animate Applet
(see also applets)
Applet class, Animate Applet, Stopping a Thread
applets, Java Terms
suspend() and resume(), The suspend() and resume() Methods, Alternatives to the suspend() and resume() methods
TCPServer class and, A Network Server Class
thread priorities in, Priority-Related Calls in the Java API
applications, Java Terms
array of threads ) (see enumerate()
ArrayTest() (example), Explicit Synchronization
associativity (mathematic), Reduction variables
asynchronous I/O, Reading Data Asynchronously, Reading Data Asynchronously, The AsyncInputStream Class, Using TCPServer with AsyncInputStreams
AsyncInputStream class (example), The AsyncInputStream Class, The AsyncInputStream Class
TCPServer class with, Using TCPServer with AsyncInputStreams
AsyncReadSocket class (example), The Current Thread, Reading Data Asynchronously, Reading Data Asynchronously, The AsyncInputStream Class
atomic routines, A Banking Example
auto-parallelizing MP C compiler, Loop Scheduling and Load Balancing
AutomatedTellerMachine class (example), A Banking Example, Return to the Banking Example
available()
AsyncInputStream class (example), The AsyncInputStream Class
FilterInputStream class, Nonblocking I/O
InputStream class, Reading Data Asynchronously, The AsyncInputStream Class

B

balancing load, Loop Scheduling and Load Balancing, Loop Scheduling and Load Balancing
Barrier class (example), Barrier, Barrier
barriers, Barrier, Barrier, Synchronization Terms
Basic class (example), Multiprocessor Scaling
blocked state, thread, An Overview of Thread Scheduling
scheduling and, Adjustment 5: Non-CPU-intensive threads, Adjustment 5: Non-CPU-intensive threads
suspended state, The suspend() and resume() Methods
blocking I/O, Nonblocking I/O, The AsyncInputStream Class
blocks, synchronized, The Synchronized Block, The Synchronized Block, Nested Locks, Wait and Notify
bound threads (Solaris), Scheduling of Solaris native threads
browsers, Java Terms
SecurityManager class and, Thread Groups, Threads, and Security
BTree class (example), Reader-Writer Locks
BusyFlag class (example), A Class to Perform Synchronization, A Class to Perform Synchronization, Nested Locks, Return to the Banking Example, Back to Work (at the Bank), Wait and Notify, Preventing Deadlock, Lock Starvation
development of, A Class to Perform Synchronization, Nested Locks
preventing deadlock (example), Preventing Deadlock, Preventing Deadlock
priority inheritance with, Priority-Inverting Locks

C

CalcRequest class (example), Adjustment 4: Devising an exit mechanism
CalcServer class (example), Adjustment 4: Devising an exit mechanism, Adjustment 4: Devising an exit mechanism
CalculateThread class (example), Manipulating Thread Groups
calculation servers, Thread Pools
calls, priority, Using the Priority Calls, When to Use Simple Priority-Based Calls
cancel() (JobScheduler; example), Job Scheduling
checkAccess(), SecurityException
SecurityManager class, Thread Groups, Threads, and Security, Thread Groups, Threads, and Security
Thread class, SecurityException
ThreadGroup class, SecurityException
child threads (see thread groups)
chunk scheduling (loops), Loop Scheduling and Load Balancing
CircularList class (example), The Circular Linked List, The Circular Linked List, A More Complete Scheduler
CircularListNode class (example), The Circular Linked List
circularly linked lists, The Circular Linked List, Synchronization and Efficiency
class locks (see classes, locking)
Class object, Synchronizing Static Methods
classes
locking, Synchronizing Static Methods , Synchronizing Static Methods , Preventing Deadlock
network server, A Network Server Class , A Network Server Class
scheduling and, Adjustment 3: More thread-safe modifications
synchronized, A Class to Perform Synchronization, A Class to Perform Synchronization, Synchronization and Efficiency
ClassExample class (example), Synchronizing Static Methods
classifying variables, Variable Classifications, Shared variables
code, Java (see virtual machine)
collection classes, Synchronization and Efficiency
synchronized collections, Explicit Synchronization
competition for locks, Lock Starvation, Reader-Writer Locks
condition variables, Condition Variables, Condition Variables, Synchronization Terms
CondVar class (example), Condition Variables, Condition Variables
constructor, thread ) (see Thread()
Consumer class (example), Thread Interruption
containers, Data Structures and Containers, Synchronization and Efficiency
countStackFrames() (Thread), Thread Stack Information, IllegalThreadStateException
CPU Processing (see performance)
CPUScheduler class (example), A More Complete Scheduler, Adjustment 5: Non-CPU-intensive threads
CPUSupport class (example), Native Scheduling Support, Implementing CPUSupport on Solaris
thread pool with, Thread Pools
critical section, Synchronization Terms
current (running) thread, Scheduling Equal-Priority Threads
currentThread() (Thread), The Current Thread, The Current Thread

D

daemon thread groups, Daemon Thread Groups
daemon threads, Daemon Threads, Adjustment 4: Devising an exit mechanism
DaemonLock class (example), Daemon Threads, Job Scheduling
data types, Data Structures and Containers, Synchronization and Efficiency
DBAccess class (example), Lock Starvation
deadlock, The Synchronized Block, Deadlock, Deadlock, Preventing Deadlock, Another Type of Deadlock
locked threads terminating, Another Type of Deadlock, Another Type of Deadlock
default
exception handler, Default Exception Handler, Default Exception Handler
priority, Priority-Related Calls in the Java API
thread, Scheduling Example: Threads of Different Priorities, Scheduling Equal-Priority Threads
delete() (CircularList; example), The Circular Linked List, A More Complete Scheduler
deleting threads and thread groups, Creating Thread Groups, Destroying Thread Groups
dereferencing thread objects, More on Starting, Stopping, and Joining
destroy()
Thread class, IllegalThreadStateException
ThreadDeath class, More on Thread Destruction
ThreadGroup class, Destroying Thread Groups
destroying threads, The ThreadDeath Class, More on Thread Destruction
distribution of loops, Loop distribution
dumpStack() (Thread), Thread Stack Information

E

end-of-file (EOF) indicator, The AsyncInputStream Class
enumerate()
Thread class, Enumerating Threads in the Virtual Machine
ThreadGroup class, Enumerating Thread Groups, Enumerating Thread Groups
enumerating thread groups, Enumerating Thread Groups, Enumerating Thread Groups
equal-priority threads, Scheduling Equal-Priority Threads, Scheduling Equal-Priority Threads
yield() with, The yield() Method, Yielding versus priority-based scheduling
event-dispatching threads, The event-dispatching thread and event-related method
event-related methods, The event-dispatching thread and event-related method
event variables, Synchronization Terms
examples of thread scheduling, Java Thread Scheduling Examples, Summary
job scheduling, Job Scheduling, Job Scheduling
round-robin scheduling, Round-Robin Scheduling, Adjustment 5: Non-CPU-intensive threads
thread pools, Thread Pools, Thread Pools
exception handler, Default Exception Handler, Default Exception Handler
exceptions, Another Type of Deadlock, Exceptions and Errors, Arbitrary Exceptions
execute(), executeAt(), executeIn() (JobScheduler; example), Job Scheduling
executeAtAndRepeat(), executeInAnd-Repeat() (JobScheduler; example), Job Scheduling
exiting state, thread, An Overview of Thread Scheduling, Adjustment 2: Making CPUScheduler thread safe
explicit synchronization, Explicit Synchronization, Explicit synchronization and native code

F

fairness in thread scheduling, Round-Robin Scheduling and “Fairness”, Round-Robin Scheduling and “Fairness”
FilterInputStream class, The AsyncInputStream Class
find(), The Circular Linked List
finding thread groups, Finding Thread Groups
Fractal applet (example), Using the Priority Calls, The suspend() and resume() Methods, The yield() Method
freeBusyFlag() (BusyFlag; example), A Class to Perform Synchronization, Nested Locks, Nested Locks, Wait and Notify, Wait and Notify
QueuedBusyFlag class (example), Lock Starvation

G

garbage collection, More on Starting, Stopping, and Joining, Daemon Threads
thread pools, Thread Pools
getBusyFlag() (BusyFlag; example), A Class to Perform Synchronization, The Synchronized Block, The Synchronized Block, Wait and Notify, Wait and Notify
QueuedBusyFlag class (example), Lock Starvation
getBusyFlagOwner() (BusyFlag; example), Nested Locks, Nested Locks
getMaxPriority() (ThreadGroup), Thread Group Priority Calls
getName()
Thread class, Thread Naming, The Current Thread
ThreadGroup class, Miscellaneous Methods
getParent() (ThreadGroup), Finding Thread Groups
getPriority() (Thread), Priority-Related Calls in the Java API, When to Use Simple Priority-Based Calls
getResource() (ResourceThrottle; example), wait(), notify(), and notifyAll()
GetSystemInfo() (Windows), Implementing CPUSupport on Windows
getThreadGroup() (ThreadGroup), Finding Thread Groups
global variables (see static variables)
graphical interfaces, Why Threads?
green-thread model, Threading Models, Green Threads, Scheduling of green threads, Adjustment 5: Non-CPU-intensive threads
groups, thread (see thread groups)
guided self-scheduling loops, Loop Scheduling and Load Balancing
GuidedLoopInterchanged class (example), Multiprocessor Scaling

H

hierarchy
lock, Preventing Deadlock
thread, Thread Group Concepts, General Thread Information

I

I/O (input/output), Nonblocking I/O
IllegalArgumentException exception, IllegalArgumentException
IllegalMonitorStateException exception, IllegalMonitorStateException
IllegalThreadStateException exception, IllegalThreadStateException
image loading, When to Use Simple Priority-Based Calls
inheritance, Threading Using the Runnable Interface
priority inheritance, Priority Inversion and Inheritance
from ThreadDeath class, Inheriting from the ThreadDeath Class
initial state, thread, An Overview of Thread Scheduling
inner loops, Inner-Loop Threading, Inner-Loop Threading
InputStream class, Reading Data Asynchronously, The AsyncInputStream Class
insert() (CircularList; example), The Circular Linked List, A More Complete Scheduler
instance variables, Overview of Multitasking, Overview of Multithreading
interactive programs, Java Thread Scheduling
interfaces, Threading Using the Runnable Interface
interpreter (see java interpreter)
interprocess communications (IPC), Data Structures and Containers
interrupt()
Thread class, Thread Interruption, Interrupted I/O
ThreadGroup class, Manipulating Thread Groups, Manipulating Thread Groups
interrupted() (Thread), Thread Interruption
InterruptedException exception, Thread Interruption, InterruptedException
InterruptedIOException exception, Interrupted I/O, InterruptedIOException
interrupting threads, Thread Interruption, Interrupted I/O
inversion of thread priority, Priority Inversion and Inheritance, Priority-Inverting Locks, Priority-Inverting Locks
invokeAndWait(), The invokeAndWait() method, Other thread-unsafe classes
invokeLater(), The invokeLater() method
I/O (input/output), Nonblocking I/O
asynchronous, Reading Data Asynchronously, Reading Data Asynchronously, The AsyncInputStream Class, Using TCPServer with AsyncInputStreams
blocking I/O, Nonblocking I/O, The AsyncInputStream Class
interrupted, Interrupted I/O, Interrupted I/O
InterruptedIOException exception, InterruptedIOException
I/O-intensive programs, Java Thread Scheduling
IOException, The AsyncInputStream Class
IPC (interprocess communications), Data Structures and Containers
isActive(), Threading Using the Runnable Interface
isAlive()
this reference and, Joining Threads
Thread class, The isAlive() Method, The isAlive() Method, Enumerating Threads in the Virtual Machine
isDaemon()
Thread class, Daemon Threads
ThreadGroup class, Daemon Thread Groups
isDestroyed() (ThreadGroup), Destroying Thread Groups
isInterrupted(), Thread Interruption
isolation, loop, Loop isolation

J

Java Foundation Classes, Using the Java Foundation Classes
java interpreter, Java Terms
scheduling (see scheduling threads)
Java, definition of, Java Terms
JDBC-ODBC bridge, Explicit synchronization and native code
JFC, single-thread access with, Using the Java Foundation Classes
job scheduling, Job Scheduling, Job Scheduling
JobScheduler class (example), Job Scheduling, Job Scheduling
join() (Thread), Joining Threads, Joining Threads, More on Starting, Stopping, and Joining, More on Starting, Stopping, and Joining, InterruptedException
barrier synchronization example, Barrier
this reference and, Joining Threads
joining threads, Joining Threads, Joining Threads, More on Starting, Stopping, and Joining, More on Starting, Stopping, and Joining
jre interpreter, Java Terms

K

Kitchen class (example), Preventing Deadlock, Preventing Deadlock

L

level, priority (see priority, thread)
lightweight processes (LWPs), Solaris Native Threads, LWPs in the virtual machine
linked lists, The Circular Linked List, Synchronization and Efficiency
of thread priorities, Scheduling Equal-Priority Threads
list of threads ) (see enumerate()
list()
Thread class, General Thread Information
ThreadGroup class, Enumerating Thread Groups
listing threads in groups, Enumerating Thread Groups, Enumerating Thread Groups
load balancing, Loop Scheduling and Load Balancing, Loop Scheduling and Load Balancing
loading images, When to Use Simple Priority-Based Calls
local variables, Overview of Multitasking, Overview of Multithreading
locks, Synchronization Terms
barriers, Barrier, Barrier, Synchronization Terms
class locks, Synchronizing Static Methods , Synchronizing Static Methods
condition variables, Condition Variables, Condition Variables, Synchronization Terms
deadlock, The Synchronized Block, Deadlock, Deadlock, Preventing Deadlock, Another Type of Deadlock
held by terminating threads, Another Type of Deadlock, Another Type of Deadlock
hierarchy of, Preventing Deadlock
IllegalMonitorStateException, IllegalMonitorStateException
lock starvation, Lock Starvation, Reader-Writer Locks
priority-inverting locks, Priority-Inverting Locks, Priority-Inverting Locks
mutex, A Banking Example, Synchronization Terms
nested, Nested Locks, Nested Locks, Deadlock
reader-writer, Synchronization Terms, Reader-Writer Locks, Reader-Writer Locks
releasing without scheduling event, Lock Starvation
scope of, Reading Data Asynchronously
LockTest class (example), Scheduling of green threads
LoopHandler class (example), Parallelizing a Single-Threaded Program
LoopPrinter class (example), Multiprocessor Scaling
loops
analysis and transformation, Loop Analysis and Transformations, Loop reimplementation
loop distribution, Loop distribution
loop isolation, Loop isolation
reimplementing loops, Loop reimplementation
inner-loop threading, Inner-Loop Threading, Inner-Loop Threading
loop-private variables, Loop-private variables
multilayered, Loop interchange
parallelizing, Parallelizable Algorithms
printing with, Loop Printing, Loop Printing, Multiprocessor Scaling
scheduling, Loop Scheduling and Load Balancing, Loop Scheduling and Load Balancing
lwp threading model (see green-thread model)
LWPs (lightweight processes), Solaris Native Threads, LWPs in the virtual machine

M

main(), Overview of Multitasking, Threading Using the Thread Class
makeCookie() (Kitchen; example), Preventing Deadlock
makeOmelette() (Kitchen; example), Preventing Deadlock
maximum thread priority, Priority-Related Calls in the Java API, Thread Group Priority Calls
MAX_PRIORITY variable, Priority-Related Calls in the Java API, Thread Group Priority Calls
MediaTracker class, Thread Pools
memory, shared, Shared Memory
message queues, The Message Queue
methods
scope of, Reading Data Asynchronously
static, Synchronizing Static Methods , Synchronizing Static Methods , wait() and sleep(), Static Methods (Synchronization Details)
synchronized, A Class to Perform Synchronization, Nested Locks, Wait and Notify, Preventing Deadlock
synchronized, Reading Data Asynchronously
(see also synchronization)
MIN_PRIORITY variable, Priority-Related Calls in the Java API
monitors, Synchronization Terms
(see also locks)
MsgQueue class (example), The Message Queue
multilayered loops, Loop interchange
multiplexing, Nonblocking I/O
multiprocessor machines, Why Threads?, Parallelizing for Multiprocessor Machines , Summary
inner-loop threading, Inner-Loop Threading, Inner-Loop Threading
loop printing, Loop Printing, Loop Printing, Multiprocessor Scaling
multiprocess scaling, Multiprocessor Scaling, Multiprocessor Scaling
single-threaded programs, Parallelizing a Single-Threaded Program, Loop reimplementation
loop analysis and transformation, Loop Analysis and Transformations, Loop reimplementation
loop scheduling and load balancing, Loop Scheduling and Load Balancing, Loop Scheduling and Load Balancing
variable classification, Variable Classifications, Shared variables
multitasking, Overview of Multitasking, Overview of Multitasking, The Message Queue
multithreading, Overview of Multithreading, Overview of Multithreading
activeCount() (Thread), Enumerating Threads in the Virtual Machine
lock starvation, Lock Starvation, Reader-Writer Locks
multiple CPU-intensive threads, When to Use Simple Priority-Based Calls
multiprocessor machines and, Parallelizing for Multiprocessor Machines , Summary
inner-loop threading, Inner-Loop Threading, Inner-Loop Threading
loop printing, Loop Printing, Loop Printing, Multiprocessor Scaling
multiprocess scaling, Multiprocessor Scaling, Multiprocessor Scaling
single-threaded programs, Parallelizing a Single-Threaded Program, Loop reimplementation
notify() and, wait(), notify(), and notifyAll(), wait(), notify(), and notifyAll()
reader-writer locks, Synchronization Terms, Reader-Writer Locks, Reader-Writer Locks
single-thread access, Single-Thread Access, Other thread-unsafe classes
thread life cycle, The Life Cycle of a Thread, Joining Threads
mutex (mutually exclusive) locks, A Banking Example, Synchronization Terms
MyJoinApplet applet (example), More on Starting, Stopping, and Joining
MyServer class (example), A Network Server Class
MyStatic class (example), Synchronizing Static Methods
MyStaticClass class (example), Static Methods (Synchronization Details)
MyThread class (example), Lock Starvation

N

names, thread, Thread Naming, Thread Naming
nanosecond counting, Animate Applet
native-thread model, Threading Models, Native Scheduling Support, Implementing CPUSupport on Solaris
32-bit Windows, Windows Native Threads, Scheduling of Windows native threads
Solaris, Solaris Native Threads, LWPs in the virtual machine
nested locks, Nested Locks, Nested Locks, Deadlock
network sockets, Reading Data Asynchronously, A Network Server Class , A Network Server Class
nonblocking I/O, Nonblocking I/O
NORM_PRIORITY variable, Priority-Related Calls in the Java API
notify() (Object), Wait and Notify, Summary, IllegalMonitorStateException
multiple threads and, wait(), notify(), and notifyAll(), wait(), notify(), and notifyAll()
in static methods, Static Methods (Synchronization Details)
notifyAll() (Object), wait(), notify(), and notifyAll(), wait(), notify(), and notifyAll(), The AsyncInputStream Class, Lock Starvation, IllegalMonitorStateException
NullPointerException exception, NullPointerException
number of threads ; enumerate()) (see activeCount()

O

Object class, Wait and Notify
objects, Overview of Multithreading
(see also instance variables)
locking, Reading Data Asynchronously, The Synchronized Block, Synchronizing Static Methods
OurApplet applet (example), Threading Using the Thread Class, Threading Using the Runnable Interface, Threading Using the Runnable Interface
OurClass class (example), Threading Using the Thread Class, Threading Using the Thread Class, Threading Using the Runnable Interface

P

parallelizable algorithms, Parallelizable Algorithms
parallelizing for multiprocessor machines, Parallelizing for Multiprocessor Machines , Summary
inner-loop threading, Inner-Loop Threading, Inner-Loop Threading
loop printing, Loop Printing, Loop Printing, Multiprocessor Scaling
multiprocess scaling, Multiprocessor Scaling, Multiprocessor Scaling
single-threaded programs, Parallelizing a Single-Threaded Program, Loop reimplementation
loop analysis and transformation, Loop Analysis and Transformations, Loop reimplementation
loop scheduling and load balancing, Loop Scheduling and Load Balancing, Loop Scheduling and Load Balancing
variable classification, Variable Classifications, Shared variables
parent threads (see thread groups)
parentOf() (ThreadGroup), Finding Thread Groups
performance, Why Threads?, Java Thread Scheduling
(see also scheduling threads)
load balancing, Loop Scheduling and Load Balancing, Loop Scheduling and Load Balancing
lock starvation, Lock Starvation, Reader-Writer Locks
multiple CPU-intensive threads, When to Use Simple Priority-Based Calls
scaling and, Multiprocessor Scaling, Multiprocessor Scaling
synchronizing classes, Synchronization and Efficiency
polling, Nonblocking I/O
PoolLoopHandler class (example), Inner-Loop Threading
PoolSelfLoopHandler class (example), Inner-Loop Threading
printing thread information, General Thread Information
printing with loops, Loop Printing, Loop Printing, Multiprocessor Scaling
priority, thread, An Overview of Thread Scheduling, Scheduling Example: Threads of Different Priorities
equal-priority threads, Scheduling Equal-Priority Threads, Scheduling Equal-Priority Threads
yield() with, The yield() Method, Yielding versus priority-based scheduling
lock starvation and, Lock Starvation
priority inheritance, Priority Inversion and Inheritance
priority inversion, Priority Inversion and Inheritance, Priority-Inverting Locks, Priority-Inverting Locks
round-robin scheduling, Round-Robin Scheduling, Round-Robin Scheduling and “Fairness”, Round-Robin Scheduling and “Fairness”
examples, Round-Robin Scheduling, Adjustment 5: Non-CPU-intensive threads
scheduling by, Scheduling with Thread Priorities, When to Use Simple Priority-Based Calls
thread groups and, Thread Group Priority Calls
threading models, Threading Models, Threading Models
green-thread model, Threading Models, Green Threads, Scheduling of green threads, Adjustment 5: Non-CPU-intensive threads
native-thread model, Threading Models, Windows Native Threads, LWPs in the virtual machine
variables for, Priority-Related Calls in the Java API
PriorityBusyFlag class (example), Priority-Inverting Locks
private variables (see local variables)
ProcessIt class (example), Barrier, Barrier
programs, Java Terms, Java Thread Scheduling

Q

QueuedBusyFlag class (example), Lock Starvation
queues, message, The Message Queue

R

race conditions, More on Starting, Stopping, and Joining, Reading Data Asynchronously, Reading Data Asynchronously
reduction variables, Reduction variables
stopping stopped threads, More on Starting, Stopping, and Joining
wait and notify mechanism, Wait and Notify
read(), Nonblocking I/O
read-only variables, Read-only variables
reader-writer locks, Synchronization Terms, Reader-Writer Locks, Reader-Writer Locks
reduction variables, Reduction variables, Reduction variables
references, The Synchronized Block, A Network Server Class
reimplementing loops, Loop reimplementation
removeThread() (CPUScheduler; example), Adjustment 1: Synchronizing data within the CPUScheduler, Adjustment 2: Making CPUScheduler thread safe
removeUseless() (example), Deadlock
repaint(), The repaint() method
ResourceThrottle class (example), wait(), notify(), and notifyAll()
restarting threads, More on Starting, Stopping, and Joining
resume()
Thread class, The suspend() and resume() Methods, Alternatives to the suspend() and resume() methods
ThreadGroup class, Manipulating Thread Groups, Manipulating Thread Groups
round-robin scheduling, Round-Robin Scheduling, Round-Robin Scheduling and “Fairness”, Round-Robin Scheduling and “Fairness”, Round-Robin Scheduling, Adjustment 5: Non-CPU-intensive threads, Lock Starvation
routines, atomic, A Banking Example
run(), Threading Using the Thread Class, Threading Using the Thread Class
CPUScheduler class (example), A More Complete Scheduler, Adjustment 2: Making CPUScheduler thread safe
isAlive() and, The isAlive() Method
StockHandler class (example), Interrupted I/O
synchronizing, Reading Data Asynchronously, Reading Data Asynchronously
TCPServer class (example), A Network Server Class
Thread class, Default Exception Handler, Arbitrary Exceptions
ThreadPool class (example), Thread Pools
run-time exceptions, Another Type of Deadlock, RuntimeException
Runnable interface, Threading Using the Runnable Interface, Threading Using the Runnable Interface, A Network Server Class
thread pools and, Thread Pools
runnable state, thread, An Overview of Thread Scheduling
RuntimeException exception, RuntimeException
RWLock class (example), Reader-Writer Locks
RWNode class (example), Reader-Writer Locks

S

ScaleTest class (example), Multiprocessor Scaling, Multiprocessor Scaling
scaling multiprocessors, Multiprocessor Scaling, Multiprocessor Scaling
scheduling threads, An Overview of Thread Scheduling, Daemon Threads
(see also priority, thread)
equal-priority threads, Scheduling Equal-Priority Threads, Scheduling Equal-Priority Threads
yield() with, The yield() Method, Yielding versus priority-based scheduling
examples of, Java Thread Scheduling Examples, Summary
fairness, Round-Robin Scheduling and “Fairness”, Round-Robin Scheduling and “Fairness”
job scheduling, Job Scheduling, Job Scheduling
native scheduling support, Native Scheduling Support, Implementing CPUSupport on Solaris
by priority, Scheduling with Thread Priorities, When to Use Simple Priority-Based Calls
priority inheritance, Priority Inversion and Inheritance
priority inversion, Priority Inversion and Inheritance, Priority-Inverting Locks, Priority-Inverting Locks
round-robin scheduling, Round-Robin Scheduling, Round-Robin Scheduling and “Fairness”, Round-Robin Scheduling and “Fairness”, Lock Starvation
examples, Round-Robin Scheduling, Adjustment 5: Non-CPU-intensive threads
suspend() and resume(), The suspend() and resume() Methods, Alternatives to the suspend() and resume() methods
synchronization and, Adjustment 1: Synchronizing data within the CPUScheduler
thread pools, Thread Pools, Thread Pools
threading models, Threading Models, Threading Models
green-thread model, Threading Models, Green Threads, Scheduling of green threads, Adjustment 5: Non-CPU-intensive threads
native-thread model, Threading Models, Windows Native Threads, LWPs in the virtual machine
yield(), The yield() Method, The yield() Method
SchedulingExample class (example), Scheduling Example: Threads of Different Priorities, Scheduling Example: Threads of Different Priorities
scope of a lock, Reading Data Asynchronously
security, Thread Groups, Threads, and Security, Thread Groups, Threads, and Security
SecurityException exception, SecurityException
SecurityManager class, Thread Groups, Threads, and Security, Thread Groups, Threads, and Security
self-scheduling loops, Loop Scheduling and Load Balancing
SelfLoopHandler class (example), Loop Scheduling and Load Balancing
semaphores, Nested Locks, Synchronization Terms
serialization, scaling and, Multiprocessor Scaling
ServerHandler class (example), A Network Server Class , Using TCPServer with AsyncInputStreams
thread groups and, Manipulating Thread Groups
servers, network, A Network Server Class , A Network Server Class
ServerSocket object, A Network Server Class
setDaemon()
Thread class, Daemon Threads, IllegalThreadStateException
ThreadGroup class, Daemon Thread Groups
setMaxPriority() (ThreadGroup), Thread Group Priority Calls
setName(), Thread Naming
setPriority() (Thread), Priority-Related Calls in the Java API, When to Use Simple Priority-Based Calls, Adjustment 2: Making CPUScheduler thread safe, IllegalArgumentException, SecurityException
setResource() (ResourceThrottle; example), wait(), notify(), and notifyAll()
setup time (for scaling), Multiprocessor Scaling
shared memory, Shared Memory
shared variables, Reduction variables, Shared variables
ShareMemory class (example), Shared Memory
shutdown(), Interrupted I/O
signals, Nonblocking I/O
SimpleScheduler class (example), A Simple Round-Robin Scheduler
simultaneous execution, Overview of Multithreading
single-thread access, Single-Thread Access, Other thread-unsafe classes
single-threaded programs, parallelizing, Parallelizing a Single-Threaded Program, Loop reimplementation
loop analysis/transformation, Loop Analysis and Transformations, Loop reimplementation
loop scheduling and load balancing, Loop Scheduling and Load Balancing, Loop Scheduling and Load Balancing
variable classification, Variable Classifications, Shared variables
SinTable class (example), Parallelizing a Single-Threaded Program, Parallelizing a Single-Threaded Program, Loop Scheduling and Load Balancing, Loop distribution, Inner-Loop Threading, Loop Printing
skip(), The AsyncInputStream Class
sleep()
Applet class, Animate Applet, Animate Applet, Threading Using the Runnable Interface
Thread class, wait() and sleep(), InterruptedException
sockets, Reading Data Asynchronously, A Network Server Class , A Network Server Class
Solaris native-threading model, Solaris Native Threads, LWPs in the virtual machine, Implementing CPUSupport on Solaris
stack, thread, Thread Stack Information
start()
Applet class, Threading Using the Thread Class, Stopping a Thread, More on Starting, Stopping, and Joining, More on Starting, Stopping, and Joining
Thread class, Default Exception Handler, IllegalThreadStateException
startServer() (TCPServer; example), A Network Server Class
starvation, lock, Lock Starvation, Reader-Writer Locks
priority-inverting locks, Priority-Inverting Locks, Priority-Inverting Locks
state, thread, An Overview of Thread Scheduling
IllegalThreadStateException, IllegalThreadStateException
suspend() and resume() and, The suspend() and resume() Methods, Alternatives to the suspend() and resume() methods
thread groups and, Manipulating Thread Groups, Manipulating Thread Groups
yield() and, The yield() Method, The yield() Method
static methods, Synchronizing Static Methods , Synchronizing Static Methods , wait() and sleep(), Static Methods (Synchronization Details)
(see also methods)
static scheduling (loops), Loop Scheduling and Load Balancing
static variables, Overview of Multitasking, Overview of Multithreading
staticNotify() (example), Static Methods (Synchronization Details)
staticWait() (example), Static Methods (Synchronization Details)
StockHandler class (example), Interrupted I/O, Interrupted I/O
StockObservable class (example), Interrupted I/O, Interrupted I/O
stop()
Applet class, Stopping a Thread, Stopping a Thread, The isAlive() Method, More on Starting, Stopping, and Joining, More on Starting, Stopping, and Joining
isAlive() and, The isAlive() Method
Thread class, NullPointerException, SecurityException
ThreadDeath class, The ThreadDeath Class, Inheriting from the ThreadDeath Class
ThreadGroup class, Manipulating Thread Groups, Manipulating Thread Groups
stopping threads, More on Starting, Stopping, and Joining, More on Starting, Stopping, and Joining, The ThreadDeath Class, Inheriting from the ThreadDeath Class
(see also stop())
garbage collection and, More on Starting, Stopping, and Joining
interrupting threads, Thread Interruption, Interrupted I/O
stopServer() (TCPServer; example), A Network Server Class
storeback variables, Storeback variables
scaling performance and, Multiprocessor Scaling
suspend()
Thread class, The suspend() and resume() Methods, Alternatives to the suspend() and resume() methods
ThreadGroup class, Manipulating Thread Groups, Manipulating Thread Groups
suspended state, thread, The suspend() and resume() Methods
SwingTest class (example), The invokeAndWait() method, The invokeLater() method
symbolic priority values, Priority-Related Calls in the Java API
synchronization, A Class to Perform Synchronization, Summary, Synchronization Terms
barriers, Barrier, Barrier, Synchronization Terms
of blocks, The Synchronized Block, The Synchronized Block, Nested Locks, Wait and Notify
of classes, A Class to Perform Synchronization, A Class to Perform Synchronization, Synchronization and Efficiency
condition variables (example), Condition Variables, Condition Variables
deadlock (see deadlock)
of linked lists, The Circular Linked List
of methods, A Class to Perform Synchronization, Nested Locks, Wait and Notify, Preventing Deadlock
static methods, Synchronizing Static Methods , Synchronizing Static Methods , wait() and sleep(), Static Methods (Synchronization Details)
TCPServer class and, A Network Server Class
thread scheduler and, Adjustment 1: Synchronizing data within the CPUScheduler
thread-unsafe classes, Thread-Unsafe Classes, Other thread-unsafe classes
explicit synchronization for, Explicit Synchronization, Explicit synchronization and native code
single-thread access, Single-Thread Access, Other thread-unsafe classes
wait and notify mechanism, Wait and Notify, Wait and Notify
synchronized keyword, Preventing Deadlock
system-level threads, Green Threads, Solaris Native Threads
system thread group, Thread Group Concepts

T

TargetNotify class (example), wait(), notify(), and notifyAll()
TCPServer class (example), A Network Server Class , A Network Server Class , Thread Pools, Adjustment 4: Devising an exit mechanism
applets and, A Network Server Class
AsyncInputStream class with, Using TCPServer with AsyncInputStreams
thread groups with, Creating Thread Groups
terminating locked threads, Another Type of Deadlock, Another Type of Deadlock
Test class (example), A Simple Round-Robin Scheduler, A More Complete Scheduler, Lock Starvation
TestRead class (example), The Current Thread
TestThread class (example), An Overview of Thread Scheduling, An Overview of Thread Scheduling, A Simple Round-Robin Scheduler, A Simple Round-Robin Scheduler, A More Complete Scheduler
this reference, join() and isAlive() with, Joining Threads
Thread(), Threading Using the Thread Class, Threading Using the Runnable Interface, Thread Naming
Thread class, Threading Using the Thread Class, Stopping a Thread, Thread Groups, Threads, and Security
thread groups, Thread Groups, Summary
creating, Creating Thread Groups, Creating Thread Groups
daemon thread groups, Daemon Thread Groups
destroying, Destroying Thread Groups
enumerating threads in, Enumerating Thread Groups, Enumerating Thread Groups
finding, Finding Thread Groups
manipulating, Manipulating Thread Groups, Manipulating Thread Groups
priority and, Thread Group Priority Calls
security and, Thread Groups, Threads, and Security, Thread Groups, Threads, and Security
thread pools, Thread Pools, Thread Pools
thread-unsafe classes, Thread-Unsafe Classes, Other thread-unsafe classes
explicit synchronization for, Explicit Synchronization, Explicit synchronization and native code
single-thread access, Single-Thread Access, Other thread-unsafe classes
ThreadDeath class, The ThreadDeath Class, Inheriting from the ThreadDeath Class
ThreadGroup class, Thread Group Concepts, Summary, Summary
methods of, Thread Group Methods, Manipulating Thread Groups
threading models, Threading Models, Threading Models
green-thread model, Threading Models, Green Threads, Scheduling of green threads, Adjustment 5: Non-CPU-intensive threads
native-thread model, Threading Models, Windows Native Threads, LWPs in the virtual machine
round-robin scheduling, Round-Robin Scheduling, Round-Robin Scheduling and “Fairness”, Round-Robin Scheduling and “Fairness”, Round-Robin Scheduling, Adjustment 5: Non-CPU-intensive threads, Lock Starvation
ThreadPool class, Thread Pools, Thread Pools
threads, Thread Overview, Overview of Multithreading
accessing specific, Thread Access, Enumerating Threads in the Virtual Machine
active (see active threads)
current thread, The Current Thread, The Current Thread
daemon versus user, Daemon Threads
data types for (see data types)
default, Scheduling Example: Threads of Different Priorities, Scheduling Equal-Priority Threads
destroying, The ThreadDeath Class, More on Thread Destruction
enumerating thread groups, Enumerating Thread Groups, Enumerating Thread Groups
getting list of ) (see enumerate()
hierarchy of, Thread Group Concepts, General Thread Information
interrupting, Thread Interruption, Interrupted I/O
joining, Joining Threads, Joining Threads, More on Starting, Stopping, and Joining, More on Starting, Stopping, and Joining
life cycle of, The Life Cycle of a Thread, Joining Threads
multiprocessor machines and, Parallelizing for Multiprocessor Machines , Summary
inner-loop threading, Inner-Loop Threading, Inner-Loop Threading
loop printing, Loop Printing, Loop Printing, Multiprocessor Scaling
multiprocess scaling, Multiprocessor Scaling, Multiprocessor Scaling
naming, Thread Naming, Thread Naming
native scheduling support, Native Scheduling Support, Implementing CPUSupport on Solaris
number of ) (see activeCount()
popular scheduling implementations, Popular Scheduling Implementations, LWPs in the virtual machine
green-thread model, Green Threads, Scheduling of green threads
Solaris native threads, Solaris Native Threads, LWPs in the virtual machine
Windows native threads, Windows Native Threads, Scheduling of Windows native threads
priority (see priority, thread)
restarting, More on Starting, Stopping, and Joining
scheduling examples, Java Thread Scheduling Examples, Summary
job scheduling, Job Scheduling, Job Scheduling
round-robin scheduling, Round-Robin Scheduling, Adjustment 5: Non-CPU-intensive threads
thread pools, Thread Pools, Thread Pools
single-threaded programs, Parallelizing a Single-Threaded Program, Loop reimplementation
loop analysis/transformation, Loop Analysis and Transformations, Loop reimplementation
loop scheduling and load balancing, Loop Scheduling and Load Balancing, Loop Scheduling and Load Balancing
variable classification, Variable Classifications, Shared variables
stack information, Thread Stack Information
stopping, Stopping a Thread, Stopping a Thread, More on Starting, Stopping, and Joining, More on Starting, Stopping, and Joining
system- and user-level, Green Threads, Solaris Native Threads
timeouts, Alarms and Timers, wait() and sleep(), wait() and sleep()
timers, Alarms and Timers, Animate Applet, Round-Robin Scheduling and “Fairness”, Round-Robin Scheduling and “Fairness”, A Simple Round-Robin Scheduler, A Simple Round-Robin Scheduler
TimerThread class (example), Animate Applet, Thread Naming
timesliced behavior (see round-robin scheduling)
toString() (Thread), General Thread Information
transformation, loops, Loop Analysis and Transformations, Loop reimplementation
loop distribution, Loop distribution
loop isolation, Loop isolation
reimplementing loops, Loop reimplementation
tryGetBusyFlag()
BusyFlag class (example), A Class to Perform Synchronization
QueuedBusyFlag class (example), Lock Starvation
tryGetBusyFlag() (BusyFlag; example), Wait and Notify

U

uncaughtException()
Thread class, Default Exception Handler
ThreadGroup class, Miscellaneous Methods
updateFolders() (example), Deadlock
user threads, Daemon Threads
user-defined scheduler (loops), Loop Scheduling and Load Balancing
user-level threads, Green Threads, Solaris Native Threads
(see also green-thread model)

V

variables, Overview of Multitasking
classification of, Variable Classifications, Shared variables
condition variables, Condition Variables, Condition Variables, Synchronization Terms
global (see static variables)
loop-private, Loop-private variables
private (see local variables)
read-only, Read-only variables
reduction, Reduction variables, Reduction variables
shared, Reduction variables, Shared variables
storeback variables, Storeback variables, Multiprocessor Scaling
thread priority, Priority-Related Calls in the Java API
Vector class (example), Lock Starvation
virtual machine, Java Terms
daemon versus user threads, Daemon Threads
enumerating threads in, Enumerating Threads in the Virtual Machine
scaling and, Multiprocessor Scaling

W

wait() (Object), Wait and Notify, Summary, InterruptedException, IllegalMonitorStateException
in static methods, Static Methods (Synchronization Details)
WaitExample class (example), wait() and sleep()
waitForAll() (ThreadPool), Thread Pools
waking up threads , notifyAll()) (see notify()
web browsers, Java Terms
SecurityManager class and, Thread Groups, Threads, and Security
Windows native-threading model, Windows Native Threads, Scheduling of Windows native threads, Implementing CPUSupport on Windows

Y

yield() (Thread), The yield() Method, The yield() Method
YieldApplet applet (example), The yield() Method
..................Content has been hidden....................

You can't read the all page of ebook, please click here login for view all page.
Reset