Java How to Program Fourth Edition - DCC

Chapter 15 Multithreading 839
[Note: On many computer platforms, C and C++ programs can perform multithreading by
using system specific code libraries.]
Software Engineering Observation 15.1
Unlike many languages that do not have built-in multithreading (such as C and C++) and must
therefore make calls to operating system multithreading primitives, Java includes multithreading
primitives as part of the language itself (actually in classes Thread, ThreadGroup,
ThreadLocal and ThreadDeath of the java.lang package). This encourages the use
of multithreading among a larger part of the applications-programming community. 15.1
We will discuss many applications of concurrent programming. When programs
download large files such as audio clips or video clips from the World Wide Web, we do
not want to wait until an entire clip is downloaded before starting the playback. So we can
put multiple threads to work: One that downloads a clip and another that plays the clip so
that these activities, or tasks, may proceed concurrently. To avoid choppy playback, we will
coordinate the threads so that the player thread does not begin until there is a sufficient
amount of the clip in memory to keep the player thread busy.
Another example of multithreading is Java’s automatic garbage collection. In C and
C++, the programmer is responsible for reclaiming dynamically allocated memory. Java
provides a garbage collector thread that reclaims dynamically allocated memory that the
program no longer needs.
Testing and Debugging Tip 15.1
In C and C++, programmers must provide explicit statements that reclaim dynamically allocated
memory. When memory is not reclaimed (because a programmer forgets to do so,
because of a logic error or because an exception diverts program control), this results in an
all-too-common error called a memory leak that can eventually exhaust the supply of free
memory and may cause premature program termination. Java’s automatic garbage collection
eliminates the vast majority of memory leaks, that is, those that are due to orphaned (unreferenced)
objects. 15.1
Java’s garbage collector runs as a low-priority thread. When Java determines that there
are no longer any references to an object, it marks the object for eventual garbage collection.
The garbage-collector thread runs when processor time is available and when there are
no higher priority runnable threads. However, the garbage collector will run immediately
when the system is out of memory.
Performance Tip 15.1
Setting an object reference to null marks that object for eventual garbage collection (if
there are no other references to the object). This can help conserve memory in a system in
which a local variable that refers to an object does not go out of scope because the method
in which it appears executes for a lengthy period. 15.1
Writing multithreaded programs can be tricky. Although the human mind can perform
many functions concurrently, humans find it difficult to jump between parallel “trains of
thought.” To see why multithreading can be difficult to program and understand, try the following
experiment: open three books to page 1. Now try reading the books concurrently.
Read a few words from the first book, then read a few words from the second book, then
read a few words from the third book, then loop back and read the next few words from the
first book, and so on. After a brief time, you will appreciate the challenges of multithreading:
switching between books, reading briefly, remembering your place in each