Conceptually, a thread is a flow of control within a program. A thread is similar to the more familiar notion of a process, except that threads within the same app are much more closely related and share much of the same state. It's kind of like a golf course, which many golfers use at the same time. The threads may cooperate to share a working area. They have access to the same objects including static and instance variables within their app. However, threads have their own copies of local variables, just as players share the golf course, but not personal things like clubs and balls. Multiple threads in an app have the same problems as the golfersin a word, synchronization. Just as you can't have two sets of players blindly playing the same green at the same time, you can't have several threads trying to access the same variables without some kind of coordination. Someone is bound to get hurt. A thread can reserve the right to use an object until it's finished with its task, just as a golf party gets exclusive rights to the green until it's done. And a thread that is more important can raise its priority, asserting its right to play through. The devil is in the details, of course, and those details have historically made threads difficult to use. Fortunately, Java makes creating, controlling, and coordinating threads simpler by integrating some of these concepts directly into the language. It is common to stumble over threads when you first work with them because creating a thread exercises many of your new Java skills all at once. You can avoid confusion by remembering that two players are always involved in running a thread: a Java language Thread object that represents the thread itself and an arbitrary target object that contains the method the thread is to execute. Later, you will see that it is possible to play some sleight of hand and combine these two roles, but that special case just changes the packaging, not the relationship.

The Thread Class and the Runnable Interface

All execution in Java is associated with a Thread object, beginning with a "main" thread that is started by the Java VM to launch your app. A new thread is born when we create an instance of the java.lang.Thread class. The Thread object represents a real thread in the Java interpreter and serves as a handle for controlling and coordinating its execution. With it, we can start the thread, wait for it to complete, cause it to sleep for a time, or interrupt its activity. The constructor for the THRead class accepts information about where the thread should begin its execution. Conceptually, we would like to simply tell it what method to run, but since there are no pointers to methods in Java (not in this sense anyway), we can't specify one directly. Instead, we have to take a short detour and use the java.lang.Runnable interface to create an object that contains a "runnable" method. Runnable defines a single, general-purpose method: 

 public interface Runnable {
 abstract public void run( );
 }

Every thread begins its life by executing the run( ) method in a Runnable object, the "target object" that was passed to the thread's constructor. The run( ) method can contain any code, but it must be public, take no arguments, have no return value, and throw no checked exceptions. Any class that contains an appropriate run( ) method can declare that it implements the Runnable interface. An instance of this class is then a runnable object that can serve as the target of a new thread. If you don't want to put the run( ) method directly in your object (and very often you don't), you can always make an adapter class that serves as the Runnable for you. The adapter's run( ) method can then call any method it wants after the thread is started. We'll show examples of these options later.

Creating and starting threads

A newly born thread remains idle until we give it a figurative slap on the bottom by calling its start( ) method. The thread then wakes up and proceeds to execute the run( ) method of its target object. start( ) can be called only once in the lifetime of a thread. Once a thread starts, it continues running until the target object's run( ) method returns (or throws an unchecked exception of some kind). The start( ) method has a sort of evil twin method called stop( ), which kills the thread permanently. However, this method is deprecated and should no longer be used. We'll explain why and give some examples of a better way to stop your threads later in this chapter. We will also look at some other methods you can use to control a thread's progress while it is running. Let's look at an example. The following class, Animation, implements a run( ) method to drive its drawing loop: 

 class Animation implements Runnable {
 boolean animate = true;
 public void run( ) {
 while ( animate ) {
 // draw Frames
 ...
 }
 }
 }

To use it, we create a Thread object, passing it an instance of Animation as its target object, and invoke its start( ) method. We can perform these steps explicitly: 

 Animation happy = new Animation("Mr. Happy");
 Thread myThread = new Thread( happy );
 myThread.start( );

We have created an instance of our Animation class and passed it as the argument to the constructor for myThread. When we call the start( ) method, myTHRead begins to execute Animation's run( ) method. Let the show begin! This situation is not terribly object-oriented. More often, we want an object to handle its own threads, as shown in , which depicts a Runnable object that creates and starts its own thread. We'll show our Animation class performing these actions in its constructor, although in practice it might be better to place them in a more explicit controller method (e.g., startAnimation( )): 

n
 class Animation implements Runnable {
 Thread myThread;
 Animation (String name) {
 myThread = new Thread( this );
 myThread.start( );
 }
 ...
 }

Screenshot-1. Interaction between Animation and its thread

Java ScreenShot

In this case, the argument we pass to the Thread constructor is this, the current object (which is a Runnable). We keep the Thread reference in the instance variable myThread in case we want to interrupt the show or exercise some other kind of control later.

A natural-born thread

The Runnable interface lets us make an arbitrary object the target of a thread, as we did in the previous example. This is the most important general usage of the Thread class. In most situations in which you need to use threads, you'll create a class (possibly a simple adapter class) that implements the Runnable interface. However, we'd be remiss not to show you the other technique for creating a thread. Another design option is to make our target class a subclass of a type that is already runnable. As it turns out, the Thread class itself conveniently implements the Runnable interface; it has its own run( ) method, which we can override directly to do our bidding: 

 class Animation extends Thread {
 boolean animate = true;
 public void run( ) {
 while ( animate ) {
 // draw Frames
 ...
 }
 }
 }

The skeleton of our Animation class looks much the same as before, except that our class is now a subclass of THRead. To go along with this scheme, the default constructor of the THRead class makes itself the default target. That is, by default, the Thread executes its own run( ) method when we call the start( ) method, as shown in . Now our subclass can just override the run( ) method in the Thread class. (THRead itself defines an empty run( ) method.)

Screenshot-2. Animation as a subclass of Thread

Java ScreenShot

Next, we create an instance of Animation and call its start( ) method (which it also inherited from Thread): 

 Animation bouncy = new Animation("Bouncy");
 bouncy.start( );

Alternatively, we can have the Animation object start its thread when it is created, as before: 

 class Animation extends Thread {
 Animation (String name) {
 start( );
 }
 ...
 }

Here, our Animation object just calls its own start( ) method when an instance is created. (It's probably better form to start and stop our objects explicitly after they're created rather than starting threads as a hidden side effect of object creation, but this serves the example well.) Subclassing Thread may seem like a convenient way to bundle a thread and its target run( ) method. However, this approach often isn't the best design. If you subclass Thread to implement a thread, you are saying you need a new type of object that is a kind of THRead, which exposes all of the public API of the THRead class. While there is something satisfying about taking an object that's primarily concerned with performing a task and making it a Thread, the actual situations where you'll want to create a subclass of Thread should not be very common. In most cases, it is more natural to let the requirements of your program dictate the class structure and use Runnables to connect the execution and logic of your program. If you find you're subclassing Thread a lot, you may want to examine whether you are falling into the design trap of making objects that are really glorified functions.

Using an adapter

Finally, as we have suggested, we can build an adapter class to give us more control over how to structure the code. It is particularly convenient to create an anonymous inner class that implements Runnable and invokes an arbitrary method in our object. This almost gives the feel of starting a thread and specifying an arbitrary method to run, as if we had method pointers. For example, suppose that our Animation class provides a method called startAnimating( ), which performs setup (loads the images, etc.) and then starts a thread to perform the animation. We'll say that the actual guts of the animation loop are in a private method called drawFrames( ). We could use an adapter to run drawFrames( ) for us: 

 class Animation {
 public void startAnimating( ) {
 // do setup, load images, etc.
 ...
 // start a drawing thread
 Thread myThread = new Thread ( new Runnable( ) {
 public void run( ) { drawFrames( ); }
 } );
 myThread.start( );
 }
 private void drawFrames( ) {
 // do animation ...
 }
 }

In this code, the anonymous inner class implementing Runnable is generated for us by the compiler. We create a thread with this anonymous object as its target and have its run( ) method call our drawFrames( ) method. We have avoided implementing a generic run( ) method in our app code at the expense of generating an extra class. Note that we could be even more terse in the previous example by simply having our anonymous inner class extend Thread rather than implement Runnable. We could also start the thread without saving a reference to it if we won't be using it later: 

 new Thread( ) {
 public void run( ) { drawFrames( ); }
 }.start( );

Controlling Threads

We have seen the start( ) method used to bring a newly created thread to life. Several other instance methods let us explicitly control a thread's execution:

Deprecated methods

We should also mention three deprecated thread control methods: stop( ), suspend( ), and resume( ). The stop( ) method complements start( ); it destroys the thread. start( ) and the deprecated stop( ) method can be called only once in the thread's lifecycle. By contrast, the deprecated suspend( ) and resume( ) methods were used to arbitrarily pause and then restart the execution of a thread. Although these deprecated methods still exist in the latest version of Java (and will probably be there forever), they shouldn't be used in new code development. The problem with both stop( ) and suspend( ) is that they seize control of a thread's execution in an uncoordinated, harsh way. This makes coding difficult; it's not always easy for an app to anticipate and properly recover from being interrupted at an arbitrary point in its execution. Moreover, when a thread is seized using one of these methods, the Java runtime system must release all its internal locks used for thread synchronization. This can cause unexpected behavior and, in the case of suspend( ), can easily lead to deadlock. A better way to affect the execution of a threadwhich requires just a bit more work on your partis by creating some simple logic in your thread's code to use monitor variables (flags), possibly in conjunction with the interrupt( ) method, which allows you to wake up a sleeping thread. In other words, you should cause your thread to stop or resume what it is doing by asking it nicely rather than by pulling the rug out from under it unexpectedly. The thread examples in this tutorial use this technique in one way or another.

The sleep( ) method

We often need to tell a thread to sit idle, or "sleep," for a fixed period of time. While a thread is asleep, or otherwise blocked from input of some kind, it doesn't consume CPU time or compete with other threads for processing. For this, we can call the static method Thread.sleep( ), which affects the currently executing thread. The call causes the thread to go idle for a specified number of milliseconds: 

 try {
 // The current thread
 Thread.sleep( 1000 );
 } catch ( InterruptedException e ) {
 // someone woke us up prematurely
 }

The sleep( ) method may throw an InterruptedException if it is interrupted by another thread via the interrupt( ) method. As you see in the previous code, the thread can catch this exception and take the opportunity to perform some actionsuch as checking a variable to determine whether or not it should exitor perhaps just perform some housekeeping and then go back to sleep.

The join( ) method

Finally, if you need to coordinate your activities with another thread by waiting for it to complete its task, you can use the join( ) method. Calling a thread's join( ) method causes the caller to block until the target thread completes. Alternatively, you can poll the thread by calling join( ) with a number of milliseconds to wait. This is a very coarse form of thread synchronization. Later in this chapter, we'll look at a much more general and powerful mechanism for coordinating the activities of threads: wait( ), notify( ), and even higher-level APIs in the java.util.concurrent package.

The interrupt( ) method

Earlier we described the interrupt( ) method as a way to wake up a thread that is idle in a sleep( ), wait( ), or lengthy I/O operation. Any thread that is not running continuously (not a "hard loop") must enter one of these states periodically and so this is intended to be a point where the thread can be flagged to stop. When a thread is interrupted, its interrupt status flag is set. This can happen at any time, whether the thread is idle or not. The thread can test this status with the isInterrupted( ) method. isInterrupted(boolean), another form, accepts a Boolean value indicating whether or not to clear the interrupt status. In this way, a thread can use the interrupt status as a flag and a signal. This is indeed the prescribed functionality of the method. However, historically, this has been a weak spot, and Java implementations have had trouble getting it to work correctly in all cases. In early Java VMs (prior to Version 1.1), interrupt did not work at all. More recent versions still have problems with interrupting I/O calls. By an I/O call, we mean when an app is blocked in a read( ) or write( ) method, moving bytes to or from a source such as a file or the network. In this case, Java is supposed to throw an InterruptedIOException when the interrupt( ) is performed. However, this has never been reliable across all Java implementations. To address this in Java 1.4, a new I/O framework (java.nio) was introduced with one of its goals being to specifically address these problems. When the thread associated with an NIO operation is interrupted, the thread wakes up and the I/O stream (called a "channel") is automatically closed. (See for more about the NIO package.)

Death of a Thread

A thread continues to execute until one of the following happens:

What happens if none of these things occurs, and the run( ) method for a thread never terminates? The answer is that the thread can live on, even after what is ostensibly the part of the app that created it has finished. This means we have to be aware of how our threads eventually terminate, or an app can end up leaving orphaned threads that unnecessarily consume resources. In many cases, we really want to create background threads that do simple, periodic tasks in an app. The setDaemon( ) method can be used to mark a thread as a daemon thread that should be killed and discarded when no other nondaemon app threads remain. Normally, the Java interpreter continues to run until all threads have completed. But when daemon threads are the only threads still alive, the interpreter will exit. Here's a devilish example using daemon threads: 

 class Devil extends Thread {
 Devil( ) {
 setDaemon( true );
 start( );
 }
 public void run( ) {
 // perform evil tasks
 }
 }

In this example, the Devil thread sets its daemon status when it is created. If any Devil threads remain when our app is otherwise complete, the runtime system kills them for us. We don't have to worry about cleaning them up. Daemon threads are primarily useful in standalone Java apps and in the implementation of server frameworks, but not in component apps such as applets. Since an applet runs inside another Java app, any daemon threads it creates can continue to live until the controlling app exitsprobably not the desired effect. A browser or any other app can use ThreadGroups to contain all the threads created by subsystems of an app and then clean them up if necessary. One final note about killing threads gracefully. A very common problem new developers encounter the first time they create an app using an AWT or Swing component is that their app never exits; the Java VM seems to hang indefinitely after everything is finished. When working with graphics, Java has created an AWT thread to process input and painting events. The AWT thread is not a daemon thread, so it doesn't exit automatically when other app threads have completed, and the developer must call System.exit( ) explicitly. (If you think about it, this makes sense. Since most GUI apps are event-driven and simply wait for user input, they would otherwise simply exit after their startup code completed.)