The JavaTM Tutorial

| Start of Tutorial > Start of Trail > Start of Lesson | Search Feedback Form

Trail: Essential Java Classes
Lesson: Threads: Doing Two or More Tasks At Once

## Implementing the Runnable Interface

> 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.

> > Note: Because some old browsers don't support 1.1, the above applet is a 1.0 version (here is the 1.0 code; here's the 1.1 code). To run the 1.1 version of the applet, go to `example-1dot1/Clock.html`. For more information about running applets, refer to About Our Examples.

> The `Clock` applet uses a different technique than `SimpleThread` for providing the `run` method for its thread. Instead of subclassing `Thread`, `Clock` implements the `Runnable` interface (and therefore implements the run method defined in it). `Clock` then creates a thread and provides itself as an argument to the `Thread`'s constructor. When created in this way, the `Thread` gets its `run` method from the object passed into the constructor. The code that accomplishes this is shown in bold here:

> >     import java.awt.Graphics;
> >     import java.util.*;
> >     import java.text.DateFormat;
> >     import java.applet.Applet;

> >     public class Clock extends Applet implements Runnable {
> >         private Thread clockThread = null;
> >         public void start() {
> >             if (clockThread == null) {
> >                 clockThread = new Thread(this, "Clock");
> >                 clockThread.start();
> >             }
> >         }
> >         public void run() {
> >             Thread myThread = Thread.currentThread();
> >             while (clockThread == myThread) {
> >                 repaint();
> >                 try {
> >                     Thread.sleep(1000);
> >                 } catch (InterruptedException e){
> >                 // the VM doesn't want us to sleep anymore,
> >                 // so get back to work
> >                 }
> >             }
> >         }
> >         public void paint(Graphics g) {
> >             // get the time and convert it to a date
> >             Calendar cal = Calendar.getInstance();
> >             Date date = cal.getTime();
> >             // format it and display it
> >             DateFormat dateFormatter = DateFormat.getTimeInstance();
> >             g.drawString(dateFormatter.format(date), 5, 10);
> >         }
> >         // overrides Applet's stop method, not Thread's
> >         public void stop() {
> >             clockThread = null;
> >         }
> >     }

> The `Clock` applet's `run` method loops until the browser asks it to stop. During each iteration of the loop, the clock repaints its display. The `paint` method figures out what time it is, formats it in a localized way, and displays it. You'll see more of the `Clock` applet in The Life Cycle of a Thread which uses it to teach you about the life of a thread.

### Deciding to Use the `Runnable` Interface

> You have now seen two ways to provide the run method for a Java thread:
> 1. Subclass the `Thread` class defined in the `java.lang` package and override the `run` method.

>    > Example: See the `SimpleThread` class described in Subclassing `Thread` and Overriding `run`.

> 2. Provide a class that implements the `Runnable` interface (also defined in the `java.lang` package) and therefore implements the `run` method. In this case, a `Runnable` object provides the `run` method to the thread.

>    > Example: See the `Clock` applet just shown.

> There are good reasons for choosing either of these options over the other. However, for most cases, including that of the `Clock` applet, the following rule of thumb will guide you to the best option.

> > Rule of Thumb: If your class must subclass some other class (the most common example being `Applet`), you should use `Runnable` as described in option #2.

> To run in a Java-enabled browser, the `Clock` class has to be a subclass of the `Applet` class. Also, the `Clock` applet needs a thread so that it can continuously update its display without taking over the process in which it is running. (Some browsers might create a new thread for each applet so as 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 computer-intensive work.) But since the Java language does not support multiple class inheritance, the `Clock` class cannot be a subclass of both `Thread` and `Applet`. Thus the `Clock` class must use the `Runnable` interface to provide its threaded behavior.

| Start of Tutorial > Start of Trail > Start of Lesson | Search Feedback Form

Copyright 1995-2001 Sun Microsystems, Inc. All rights reserved.