Chapter 9. Thread Scheduling
The term "thread scheduling" covers
a variety of topics. This chapter examines one of those topics, which
is how a computer selects particular threads to run. The information
in this chapter provides a basic understanding of when threads run
and how computers handle multiple threads. There's
little programming in this chapter, but the information we present is
an important foundation for other topics of thread scheduling. In
particular, the next few chapters discuss task scheduling and thread
pools, which are the programmatic techniques you use to manage large
numbers of threads and jobs.
The key to understanding Java thread scheduling is to realize that a
CPU is a scarce resource. When two or more threads want to run on a
single-processor machine, they end up competing for the CPU, and
it's up to someone梕ither the programmer, the
Java virtual machine, or the operating system梩o make sure that
the CPU is shared among these threads. The same is true whenever a
program has more threads than the machine hosting the program has
CPUs. The essence of this chapter is to understand how CPUs are
shared among threads that want to access them.
In earlier examples, we didn't concern ourselves
with this topic because, in those cases, the details of thread
scheduling weren't important to us. This was because
the threads we were concerned with didn't normally
compete for a CPU: they had specific tasks to do, but the threads
themselves were usually short-lived or only periodically needed a CPU
in order to accomplish their task. Consider the event-processing
thread in our typing program. Most of the time, this thread
isn't using a CPU because it's
waiting for the user to do something. When the user types a character
or moves the mouse, the thread quickly processes the event and waits
for the next event; since the thread doesn't need a
CPU very often, we didn't need to concern ourselves
with the thread's scheduling.
The topic of thread scheduling is a difficult one to address because
the Java specification does not require implementations to schedule
threads in a particular manner. It provides guidelines that threads
should be scheduled based on a thread's priority,
but they are not absolute, and different implementations of the Java
virtual machine follow the guidelines differently. You cannot
guarantee the order of execution of threads across all Java virtual
machines.
|
