Threads of Control

The Clock Applet

The Clock applet shown here: displays the current time and updates its display every second. You can scroll this page and perform other tasks while the clock continues to update because the code that updates the clock's display runs within its own thread.

This page highlights and explains the source code for the clock applet in detail. In particular, this page describes the code segments that implement the clock's threaded behaviour; it does not describe the code segments that are related to the life cycle of the applet. If you have not written your own applets before or are not familiar with the life cycle of any applet, you may want to take this time to familiarize yourself with the material in The Life Cycle of an Applet before proceeding with this page.

The Decision to Use the Runnable Interface

The Clock applet uses the Runnable interface to provide the run() method for its thread. In order to run within a Java-compatible browser, the Clock class had to derive from the Applet class. However, the Clock applet also needs to use a thread so that it can continuously update its display without taking over the process in which it is running. But since the Java language does not support multiple-inheritance, the Clock class could not inherit from Thread as well as from Applet. Thus, the Clock class uses the Runnable interface to provide its threaded behaviour.

Applets are not threads nor do Java-compatible browsers or appletviewers automatically create threads in which to run applets. Therefore, if an applet needs any threads it must create its own. The clock applet needs one thread in which to perform its display updates because it updates its display frequently and the user needs to be able to perform other tasks at the same time the clock is running (such as going to another page, or scrolling this one).

The Runnable Interface

The Clock applet provides a run() method for its thread via the Runnable interface. The class definition for the Clock class indicates that the Clock is a subclass of Applet and implements the Runnable interface. If you are not familiar with interfaces review the information at Missing Page.

class Clock extends Applet implements Runnable {

The Runnable interface defines a single method called run() that takes no arguments and returns no value. Because the Clock class implements the Runnable interface, it must provide an implementation for the run() method as defined in the interface. However, before explaining the Clock's run() method we need to look at some of the other elements of the Clock code first.

Creating the Thread

The application in which an applet is running calls the applet's start() method when it loads the applet. The Clock applet creates a Thread named clockThread in its start() method and starts the thread.

public void start() {
    if (clockThread == null) {
        clockThread = new Thread(this, "Clock");
        clockThread.start();
    }
}    

First, the start() method checks to see if clockThread is null. If clockThread is null, then the applet is brand new or has been previously stopped and a new thread must be created. Otherwise, the applet is already running. The applet creates a new thread with this invocation:

clockThread = new Thread(this, "Clock");

Notice that this--the Clock applet--is passed in as the first argument to the thread constructor. The first argument to this Thread constructor must implement the Runnable interface and becomes the thread's target. When constructed in this way, the thread, clockThread, gets its run() method from its target Runnable object, in this case, the Clock applet.

The second argument is just a name for the thread.

Stopping the Thread

When you leave the page that displays the Clock applet, the application in which the applet is running calls the applet's stop() method. The Clock's stop() method stops the thread then sets it to null. This stops the continual updating of the clock.

public void stop() {
    clockThread.stop();
    clockThread = null;
}

If you revisit the page, the start() method is called again, and the clock starts up again with a new thread.

The Run Method

And finally for the Clock's run() method. The run() method implements the heart of the Clock applet and looks like this:

public void run() {
    while (clockThread != null) {
        repaint();
        try {
            clockThread.sleep(1000);
        } catch (InterruptedException e){
        }
    }
}   

As you saw in the previous section, when the applet is asked to stop, the applet stops the clockThread and then sets it to null; this lets the run() method know when to stop. Thus the first line of the run() method loops until clockThread is stopped. Within the loop, the applet repaints itself, and then tells the Thread to sleep for 1 second (1000 milliseconds). An applet's repaint() method ultimately calls the applet's paint() method which does the actual update of the applet's display area. The Clock applet's paint() method gets the current time and draws it to the screen.

public void paint(Graphics g) {
    Date now = new Date();
    g.drawString(now.getHours() + ":" + now.getMinutes() + ":" + now.getSeconds(), 5, 10);
}

Threads of Control