Programming Threads

Overview

Remember the guy from the old Ed Sullivan Show who used to spin plates? Somehow he managed to keep all those plates spinning, running from pole to pole to give each plate a little nudge-just enough to keep it going.

In Java, threads are the equivalent of the spinning plate guy. Threads let you divide the work of an application into separate pieces, which then all run simultaneously. The result is a faster and more efficient program, but along with the increased speed comes more difficult programming and debugging.

Truthfully, the subtleties of threaded programming are a topic for Computer Science majors. But the basics of working with threads aren't all that difficult to learn. In this chapter, I focus on those basics and leave the advanced techniques for the grad students.

Understanding Threads

A thread is a single sequence of executable code within a larger program. All the programs shown so far in this book have used just one thread-the main thread that starts automatically when you run the program. However, Java lets you create programs that start additional threads to perform specific tasks.

You're probably already familiar with programs that use threads to perform several tasks at once. Here are some common examples:

• Web browsers can download files while still letting you view Web pages. When you download a file in a Web browser, the browser starts a separate thread to handle the download.
• E-mail programs don't make you wait for all your messages to download before you can read the first message. Instead, these programs use separate threads to display and download messages.
• Word processors can print long documents in the background while you continue to work. These programs start a separate thread to handle print jobs.
• Word processors can also check your spelling as you type. Depending on how the word processor is written, it may run the spell check in a separate thread.
• Game programs commonly use several threads to handle different parts of the game to improve the overall responsiveness of the game.

• Tip

  All GUI-based programs use at least two threads-one thread to run the application's main logic, and another thread to monitor mouse and keyboard events. You find out about creating GUI programs in Java in Book VI.

• Indeed, the Java Virtual Machine itself uses threading for some of its housekeeping chores. For example, the garbage collector runs as a separate thread so it can constantly monitor the state of the VM's memory and decide when it needs to create some free memory by removing objects that are no longer being used.

Creating a Thread

Suppose you're developing software for NASA, and you're in charge of the program that controls the final 31 seconds of the countdown for the space shuttle. Your software has to coordinate several key events that occur when the clock reaches certain points:

• T-minus 16 seconds: Flood launch pad. This releases 350,000 gallons of water onto the launch pad, which helps protect the shuttle systems during launch. (I'm not making this part up.)
• T-minus 6 seconds: Start the main engines. In the real space shuttle, the three engines are not started all at the same time. Instead, engine 1 is started at T-minus 6.6 seconds, engine 2 is started 120 milliseconds later at T-minus 6.48 seconds, and engine 3 is started 120 milliseconds after that at T-minus 6.36 seconds. I fudge in my program and start all three engines at T-minus 6 seconds.
• T-minus 0: Lift off! The solid rocket boosters are lit, the clamps are released, and the shuttle flies into space.

For this program, I don't actually start any rocket engines or release huge amounts of water. Instead, I just display messages on the console to simulate these events. But I do create four separate threads to make everything work. One thread manages the countdown clock. The other three threads fire off their respective events at T-minus 16 seconds (flood the pad), T-minus 6 seconds (fire the engines), and T-minus 0 (launch).

For the first attempt at this program, I just get the countdown clock up and running. The countdown clock is represented by a class named CountDownClock. All this class does is count down from 20 to 0 at one-second intervals, displaying messages such as T minus 20 on the console as it counts. This version of the program doesn't do much of anything, but it does demonstrate how to get a thread going. But first, I need to have a look at the Thread class.

Understanding the Thread class

The Thread class lets you create an object that can be run as a thread in a multi-threaded Java application. The Thread class has quite a few constructors and methods, but for most applications you only need to use the ones listed in Table 1-1. (Note that this table is here to give you an overview of the Thread class and to serve as a reference. Don't worry about the details of each constructor and method just yet. By the end of this chapter, I explain each of the constructors and methods.)

Extending the Thread class

The easiest way to create a thread is to write a class that extends the Thread class. Then, all you have to do to start a thread is create an instance of your thread class and call its start method.

For example, Listing 1-1 is a version of the CountDownClock class that extends the Thread class.

Listing 1-1: The CountDownClock Class (Version 1)

public class CountDownClock extends Thread → 1 { public void run() → 3 { for (int t = 20; t >= 0; t--) → 5 { System.out.println("T minus " + t); try { Thread.sleep(1000); →10 } catch (InterruptedException e) {} } } }

Here are a few key points to notice in this class:

Open table as spreadsheet

Creating and starting a thread

After you define a class that defines a Thread object, you can create and start the thread. For example, here's the main class for the first version of the countdown application:

public class CountDownApp { public static void main(String[] args) { Thread clock = new CountDownClock(); clock.start(); } }

Here a variable of type Thread is declared, and an instance of the CountDownClock is created and assigned to it. This creates a Thread object, but the thread doesn't begin executing until you call its start method.

When you run this program, the thread starts counting down in one-second increments, displaying messages such as the following on the console:

T-minus 20 T-minus 19 T-minus 18

And so on, all the way to zero. So far, so good.

Implementing the Runnable Interface

For the threads that trigger specific countdown events such as flooding the launch pad, starting the events, or lifting off, I create another class called LaunchEvent. This class uses another technique for creating and starting threads, one that requires a few more lines of code but is more flexible.

The problem with creating a class that extends the Thread class is that a class can have one superclass. What if you'd rather have your thread object extend some other class? In that case, you can create a class that implements the Runnable interface rather than extends the Thread class. The Runnable interface marks an object that can be run as a thread. It has only one method, run, that contains the code that's executed in the thread. (The Thread class itself implements Runnable, which is why the Thread class has a run method.)

Using the Runnable interface

To use the Runnable interface to create and start a thread, you have to do the following:

1. Create a class that implements Runnable.
2. Provide a run method in the Runnable class.
3. Create an instance of the Thread class and pass your Runnable object to its constructor as a parameter.

   A Thread object is created that can run your Runnable class.

4. Call the Thread object's start method.

   The run method of your Runnable object is called, which executes in a separate thread.

The first two of these steps are easy. The trick is in the third and fourth steps, because you can complete them several ways. Here's one way, assuming that your Runnable class is named RunnableClass:

RunnableClass rc = new RunnableClass(); Thread t = new Thread(rc); t.start();

Java programmers like to be as concise as possible, so you often see this compressed to something more like this:

Thread t = new Thread(new RunnableClass()); t.start();

or even just this:

new Thread(new RunnableClass()).start();

This single-line version works-provided you don't need to access the thread object later in the program.

Creating a class that implements Runnable

To sequence the launch events for the NASA application, I create a Runnable object named LaunchEvent. The constructor for this class accepts two parameters: the countdown time at which the event fires, and the message that is displayed when the time arrives. Then, the run method for this class uses Thread.sleep to wait until the desired time arrives. Then it displays the message.

Listing 1-2 shows the code for this class.

Listing 1-2: The LaunchEvent Class (Version 1)

public class LaunchEvent implements Runnable → 1 { private int start; private String message; public LaunchEvent(int start, String message) → 6 { this.start = start; this.message = message; } public void run() { try { Thread.sleep(20000 - (start * 1000)); → 16 } catch (InterruptedException e) {} System.out.println(message); → 20 } }

The following paragraphs draw your attention to the listing's key lines:

Open table as spreadsheet

Using the CountDownApp class

Now that you've seen the code for the LaunchEvent and CountDownClock classes, Listing 1-3 shows the code for a CountDownApp class that uses these classes to launch a space shuttle.

Listing 1-3: The CountDownApp Class (Version 1)

public class CountDownApp { public static void main(String[] args) { Thread clock = new CountDownClock(); → 5 Runnable flood, ignition, liftoff; → 7 flood = new LaunchEvent(16, "Flood the pad!"); ignition = new LaunchEvent(6, "Start engines!"); liftoff = new LaunchEvent(0, "Liftoff!"); clock.start(); → 12 new Thread(flood).start(); → 14 new Thread(ignition).start(); new Thread(liftoff).start(); } }

The following paragraphs summarize how this program works:

Open table as spreadsheet

When you run this program, the following output is displayed on the console:

T minus 20 T minus 19 T minus 18 T minus 17 T minus 16 Flood the pad! T minus 15 T minus 14 T minus 13 T minus 12 T minus 11 T minus 10 T minus 9 T minus 8 T minus 7 T minus 6 Start engines! T minus 5 T minus 4 T minus 3 T minus 2 T minus 1 Liftoff! T minus 0

As you can see, the LaunchEvent messages are interspersed with the CountDownClock messages. Thus, the launch events are triggered at the correct time.

The advantage of this technique is that you don't need to create a separate variable for each LaunchEvent.

Creating Threads That Work Together

Unfortunately, the countdown application presented in the previous section has a major deficiency. The CountDownClock and LaunchEvent threads depend strictly on timing to coordinate their activities. After these threads start, they run independently of one another. As a result, random variations in their timings can cause the thread behaviors to change.

For example, if you run the program several times in a row, you'll discover that sometimes the Start engines! message appears after the T minus 6 message, and sometimes it appears before the T minus 6 message. That might not be a big deal to you, but it would probably be disastrous for the astronauts on the shuttle.

What these classes really need is a way to communicate with each other. Listing 1-4 shows an improved version of the countdown application that incorporates several enhancements. The CountDownClock class in this version adds a new method named getTime that gets the current time in the countdown. Then, the LaunchEvent class checks the countdown time every 10 milliseconds and triggers the events only when the countdown clock actually says it's time. This version of the application runs consistently.

In addition, you want to enable the LaunchEvent class to monitor the status of the CountDownClock, but you don't want to couple the LaunchEvent and CountDownClock classes too closely together. For example, suppose you later develop a better countdown clock. If the LaunchEvent class knows what class is doing the counting, you have to recompile it if you use a different countdown class.

The solution is to use an interface as a buffer between the classes. This interface defines a method that gets the current status of the clock. Then, the CountDownClock class can implement this interface, and the LaunchEvent class can use any object that implements this interface to get the time.

Listing 1-4: The CountDown Application (Version 2)

import java.util.ArrayList; // version 2.0 of the Countdown application public class CountDownApp { public static void main(String[] args) { CountDownClock clock = new CountDownClock(20); → 8 ArrayList events = new ArrayList(); → 10 events.add(new LaunchEvent(16, → 12 "Flood the pad!", clock)); events.add(new LaunchEvent(6, "Start engines!", clock)); events.add(new LaunchEvent(0, "Liftoff!", clock)); clock.start(); → 19 for (Runnable e : events) → 21 new Thread(e).start(); } } interface TimeMonitor → 26 { int getTime(); } class CountDownClock extends Thread implements TimeMonitor → 31 { private int t; → 33 public CountDownClock(int start) → 35 { this.t = start; } public void run() { for (; t >= 0; t--) → 42 { System.out.println("T minus " + t); try { Thread.sleep(1000); } catch (InterruptedException e) {} } } public int getTime() → 54 { return t; } } class LaunchEvent implements Runnable → 60 { private int start; private String message; TimeMonitor tm; → 64 public LaunchEvent(int start, String message, TimeMonitor monitor) { this.start = start; this.message = message; this.tm = monitor; } public void run() { } boolean eventDone = false; while (!eventDone) { try { Thread.sleep(10); → 81 } catch (InterruptedException e) {} if (tm.getTime() <= start) → 85 { System.out.println(this.message); eventDone = true; } } }

The following paragraphs describe the high points of this version:

Open table as spreadsheet

Using an Executor

The countdown application in Listings 1-1 through 1-3 uses Java's original threading mechanisms-tools that were available in the mid-1990s, when Java was in diapers. Since then, Java programmers have longed for newer, more sophisticated threading techniques. The big breakthrough came in 2004, with the release of Java 1.5. The Java API gained a large assortment of classes for fine-grained control of the running of threads.

A full discussion of Java 1.5 threading would require another 850 pages. (How about Java 1.5 Threading All-in-One Desk Reference For Masochists?) This chapter presents only a small sampling of the newer Java threading features.

Listings 1-5 through 1-7 repeat the work done by Listings 1-1 through 1-3, but Listings 1-5 through 1-7 use Java 1.5 threading classes.

Listing 1-5: A New CountDownClock

public class CountDownClockNew implements Runnable { int t; public CountDownClockNew(int t) { this.t = t; } public void run() { System.out.println("T minus " + t); } }

Listing 1-6: A New Event Launcher

public class LaunchEventNew implements Runnable { private String message; public LaunchEventNew(String message) { this.message = message; } public void run() { System.out.println(message); } }

Listing 1-7: A New CountDown Application

import java.util.concurrent.ScheduledThreadPoolExecutor; import java.util.concurrent.TimeUnit; class CountDownAppNew { public static void main(String[] args) { ScheduledThreadPoolExecutor pool = new ScheduledThreadPoolExecutor(25); Runnable flood, ignition, liftoff; flood = new LaunchEventNew("Flood the pad!"); ignition = new LaunchEventNew("Start engines!"); liftoff = new LaunchEventNew("Liftoff!"); for (int t = 20; t >= 0; t--) pool.schedule(new CountDownClockNew(t), (long) (20 - t), TimeUnit.SECONDS); pool.schedule(flood, 3L, TimeUnit.SECONDS); pool.schedule(ignition, 13L, TimeUnit.SECONDS); pool.schedule(liftoff, 19L, TimeUnit.SECONDS); pool.shutdown(); } }

In the new version of the countdown application, Listing 1-7 does all the busywork. The listing uses the ScheduledThreadPoolExecutor class. The class's long name tells much of the story:

• Scheduled: Using this class, you can schedule a run of code for some future time.
• ThreadPool: This class typically creates several threads (a pool of threads) all at once. When you want to run some code, you grab an available thread from the pool, and you use that thread to run your code.
• Executor: An Executor executes something. No big surprise here!

The loop in Listing 1-7 spawns 20 threads, each with its own initial delay. For example, the fifth loop iteration calls

pool.schedule(new CountDownClockNew(16), (long) (20 - 16), TimeUnit.SECONDS);

In the pool.schedule method call, the number (long) (20 - 16) tells Java to wait 4 seconds before running the T minus 16 thread. Each of the T minus threads has a different delay, so each thread runs at the appropriate time. The same is true of the flood, ignition, and liftoff events.

Synchronizing Methods

Whenever you work on a program that uses threads, you have to consider the nasty issue of concurrency. In particular, what if two threads try to access a method of an object at precisely the same time? Unless you program carefully, the result can be disastrous. A method that performs a simple calculation returns inaccurate results. In an online banking application, you might discover that some deposits are credited twice and some withdrawals aren't credited at all. In an online ordering system, one customer's order might get recorded in a different customer's account.

The key to handling concurrency issues is recognizing methods that update data and that might be called by more than one thread. After you identify those methods, the solution is simple: You just add the synchronized keyword to the method declaration, like this:

public synchronized void someMethod()...

This tells Java to place a lock on the object so that no other methods can call any other synchronized methods for the object until this method finishes. In other words, it temporarily disables multithreading for the object.

The next several listings present some concrete examples. Listing 1-8 creates an instance of the CountDownClock class (the class in Listing 1-1).

Then Listing 1-9 spawns two threads. Each thread runs a copy of the CountDownClock instance's code.

Listing 1-8: Creating Two CountDownClock Threads

import java.util.concurrent.ScheduledThreadPoolExecutor; public class DoTwoThings { ScheduledThreadPoolExecutor pool = new ScheduledThreadPoolExecutor(2); CountDownClock clock = new CountDownClock(); public static void main(String[] args) { new DoTwoThings(); } DoTwoThings() { pool.execute(clock); pool.execute(clock); pool.shutdown(); } }

The resulting output is a mishmash of two threads' outputs. The two threads execute their loops simultaneously-so after one thread displays its T minus 20, the other thread displays its own T minus 20. The same thing happens for T minus 19, T minus 18, and so on.

T minus 20 T minus 20 T minus 19 T minus 19 T minus 18 T minus 18 T minus 17 ... and so on, down to... T minus 1 T minus 1 T minus 0 T minus 0

Listing 1-9: Creating Two More CountDownClock Threads

import java.util.concurrent.ScheduledThreadPoolExecutor; public class DoTwoThingsSync { ScheduledThreadPoolExecutor pool = new ScheduledThreadPoolExecutor(2); CountDownClockSync clock = new CountDownClockSync(); public static void main(String[] args) { new DoTwoThingsSync(); } DoTwoThingsSync() { pool.execute(clock); pool.execute(clock); pool.shutdown(); } }

In Listing 1-10, Java's synchronized keyword ensures that only one thread at a time calls the run method. The resulting output shows one complete execution of the run method followed by another.

Listing 1-10: Using the synchronized Keyword

public class CountDownClockSync extends Thread { synchronized public void run() { for (int t = 20; t >= 0; t--) { System.out.println("T minus " + t); try { Thread.sleep(1000); } catch (InterruptedException e) {} } } }

The two threads' calls to the run method are not interleaved, so the output counts down from 20 to 0, and then counts down a second time from 20 to 0.

T minus 20 T minus 19 T minus 18 ... and so on, down to... T minus 2 T minus 1 T minus 0 T minus 20 T minus 19 T minus 18 ... and so on, down to... T minus 2 T minus 1 T minus 0

You'd think that because this method has just one statement, some other thread could not interrupt it in the middle. Alas, that's not the case. This method must get the value of the sequenceNumber field, add 1 to it, save the updated value back to the sequenceNumber field, and return the value. In fact, this single Java statement compiles to 11 bytecode instructions. If the thread is preempted between any of them by another thread calling the same method, the serial numbers get munged.

For safety's sake, why not just make all the methods synchronized? There are two reasons:

• It takes time to synchronize methods. Java has to acquire a lock on the object being synchronized, run the method, and then release the lock. But before it can do that, it has to check to make sure some other thread doesn't already have a lock on the object. All of this takes time.
• More importantly, synchronizing all your methods defeats the purpose of multithreading. So you should synchronize only those methods that require it.

Creating a Lock

With Java 1.5 came many new threading features. One such feature was the introduction of locks. A lock can take the place of Java's synchronized keyword, but a lock is much more versatile. Listings 1-11 and 1-12 illustrate the use of a lock.

Listing 1-11: Creating CountDownClock Threads (Again)

import java.util.concurrent.ScheduledThreadPoolExecutor; public class DoTwoThingsLocked { ScheduledThreadPoolExecutor pool = new ScheduledThreadPoolExecutor(2); CountDownClockLocked clock = new CountDownClockLocked(); public static void main(String[] args) { new DoTwoThingsLocked(); } DoTwoThingsLocked() { pool.execute(clock); pool.execute(clock); pool.shutdown(); } }

Listing 1-12: Using a Lock

import java.util.concurrent.locks.ReentrantLock; public class CountDownClockLocked extends Thread { ReentrantLock lock = new ReentrantLock(); public void run() { lock.lock(); for (int t = 20; t >= 0; t--) { System.out.println("T minus " + t); try { Thread.sleep(1000); } catch (InterruptedException e) {} } lock.unlock(); } }

Listing 1-12 is remarkably similar to Listing 1-10. The only significant difference is the replacement of the synchronized keyword by calls to ReentrantLock methods.

At the start of Listing 1-12, the code declares the variable lock-an instance of the ReentrantLock class. This lock object is like a gas station's restroom key. Only one thread at a time can have the lock object. When one thread gets the lock object-by calling lock.lock() at the start of the run method-then no other thread can get past the lock.lock() call. A second thread must wait at the lock.lock() call until the restroom key becomes available. In Listing 1-12, the restroom key becomes available only when the first thread reaches the lock.unlock() statement. After the first thread calls lock.unlock(), the second thread proceeds into the method's for loop.

The overall result is the same as the output of Listings 1-9 and 1-10. In this example, using a lock is no better than using Java's synchronized keyword. But Java 1.5 has several kinds of locks, and each kind of lock has its own useful features.

Threadus Interruptus

You can interrupt another thread by calling its interrupt method, provided you have a reference to the thread. For example:

t.interrupt();

Here the thread referenced by the t variable is interrupted. Now, all the interrupted thread has to do is find out that it has been interrupted and respond accordingly. That's the topic of the following sections.

Finding out whether you ve been interrupted

As you've already seen, several methods of the Thread class, including sleep and yield, throw InterruptedException. Up until now, I've told you to simply ignore this exception-and in many cases, that's appropriate. However, many (if not most) threads should respond to InterruptedException in one way or another. In most cases, the thread should terminate when it's interrupted.

Unfortunately, finding out if a thread has been interrupted isn't as easy as it sounds. InterruptedException is thrown when another thread calls the interrupt method on this thread while the thread is not executing. That's why the methods that can cause the thread to give up control to another thread throw this exception. That way, when the thread resumes execution, you know it was interrupted.

However, the yield and sleep methods aren't the only way for control to be wrested away from a thread. Sometimes the thread scheduler just steps in and says, "You've had enough time, now it's someone else's turn to play." If that happens, and then some other thread calls your thread's interrupt method, InterruptedException isn't thrown. Instead, a special flag called the interrupted flag is set to indicate that the thread was interrupted. You can test the status of this flag by calling the static interrupted method.

Unfortunately, that means your threads have to check twice to see whether they have been interrupted. The usual way to do that is to follow this form:

public void run() { boolean done = false boolean abort = false; while(!done) { // do the thread's work here // set done to true when finished try { sleep(100); // sleep a bit } catch(InterruptedException e) { abort = true; } if (Thread.interrupted()) abort = true; if (abort) break; } }

Here the abort boolean variable is set to true if InterruptedException is thrown or if the interrupted flag is set. Then, if abort has been set to true, a break statement is executed to leave the while loop. Of course, this scheme has a million variations. But this one works in most situations.

Aborting the countdown

To illustrate how you can interrupt threads, Listing 1-13 shows yet another version of the countdown application. This version aborts the countdown if something goes wrong with any of the launch events.

To simplify the code a bit, I assume that things aren't going well at NASA, so every launch event results in a failure that indicates to abort the countdown. Thus, whenever the start time for a LaunchEvent arrives, the LaunchEvent class attempts to abort the countdown. It goes without saying that in a real launch-control program, you wouldn't want to abort the launch unless something actually does go wrong.

Listing 1-13: The Countdown Application with Aborts

import java.util.ArrayList; public class CountDownApp → 3 { public static void main(String[] args) { CountDownClock clock = new CountDownClock(20); ArrayList events = new ArrayList(); events.add(new LaunchEvent(16, "Flood the pad!", clock)); events.add(new LaunchEvent(6, "Start engines!", clock)); events.add(new LaunchEvent(0, "Liftoff!", clock)); clock.start(); for (Runnable e : events) new Thread(e).start(); } } interface TimeMonitor { int getTime(); void abortCountDown(); → 26 } class CountDownClock extends Thread implements TimeMonitor { private int t; public CountDownClock(int start) { this.t = start; } public void run() { boolean aborted = false; → 40 for (; t >= 0; t--) { System.out.println("T minus " + t); try { Thread.sleep(1000); } catch (InterruptedException e) { aborted = true; → 50 } if (Thread.interrupted()) aborted = true; → 53 if (aborted) → 54 { System.out.println( "Stopping the clock!"); break; } } } public int getTime() { return t; } public synchronized void abortCountDown() → 67 { Thread[] threads = new Thread[Thread.activeCount()]; → 69 Thread.enumerate(threads); → 70 for(Thread t : threads) → 71 t.interrupt(); } } class LaunchEvent implements Runnable { private int start; private String message; TimeMonitor tm; public LaunchEvent(int start, String message, TimeMonitor monitor) { this.start = start; this.message = message; this.tm = monitor; } public void run() { boolean eventDone = false; boolean aborted = false; → 92 while (!eventDone) { try { Thread.sleep(10); } catch (InterruptedException e) { aborted = true; → 101 } if (tm.getTime() <= start) { System.out.println(this.message); eventDone = true; System.out.println("ABORT!!!!"); → 107 tm.abortCountDown(); → 108 } if (Thread.interrupted()) aborted = true; → 111 if (aborted) → 112 { System.out.println( "Aborting " + message); break; } } } }

The following paragraphs point out the highlights of this program:

Open table as spreadsheet

When you run this version of the countdown application, here's what appears on the console:

T minus 20 T minus 19 T minus 18 T minus 17 T minus 16 Flood the pad! ABORT!!!! Stopping the clock! Aborting Flood the pad! Aborting Start engines! Aborting Liftoff!