| Threads of Control

## The Clock Applet

> The Clock applet shown below 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.

> > Your browser doesn't understand the APPLET tag. Here's a screenshot of the clock applet that you would see running here if it did:

> This section 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 behavior; 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.

> #### Deciding to Use the Runnable Interface

> > The Clock applet uses the Runnable interface to provide the `run()` method for its thread. To run within a Java-compatible browser, the Clock class has 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. (Some, but not all, browsers create a new thread for every applet to prevent a misbehaved applet from taking over the main browser thread. However, you should not count on this when writing your applets; your applets should create their own threads when doing compute-intensive work.) But since the Java language does not support multiple inheritance, the Clock class can not inherit from Thread as well as from Applet. Thus, the Clock class must use the Runnable interface to provide its threaded behavior.

> > Applets are not threads, nor do any existing Java-compatible browsers or applet viewers 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 in the Objects, Classes, and Interfaces lesson.

> > >     class Clock extends Applet implements Runnable {

> > The Runnable interface defines a single method called `run()` that doesn't accept any arguments and doesn't return a 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, let's to look at some of the other elements of the Clock code.

> #### Creating the Thread

> > The application in which an applet is running calls the applet's `start()` method when the user visits the applet's page. The Clock applet creates a Thread, `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 has just been loaded 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 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 clock thread 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 sets the `clockThread` to null. This tells the main loop in the `run()` method to terminate (see the next section), eventually resulting in the thread stopping and being garbage collected. the continual updating of the clock.

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

> > You could use `clockThread.stop()` instead, which would immediately stop the clock thread. However, the Thread class's `stop()` method has a sudden effect, which means that the `run()` method might be in the middle of some critical operation when the thread is stopped. For more complex `run()` methods, using Thread's `stop()` method might leave the program in an inconsistent or awkward state. For this reason, it's best to avoid using the Thread class's `stop()` method when possible.

> > 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 the Clock's `run()` method implements the heart of the Clock applet and looks like this:

> > >     public void run() {
> > >             // loop terminates when clockThread is set to null in stop()
> > >         while (Thread.currentThread() == clockThread) {
> > >             repaint();
> > >             try {
> > >                 Thread.sleep(1000);
> > >             } catch (InterruptedException e){
> > >             }
> > >         }
> > >     }

> > As you saw in the previous section, when the applet is asked to stop, the applet sets the `clockThread` to null; this lets the `run()` method know when to stop. Thus the first line of the `run()` method loops until `clockThread` is null. 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