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. 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 with itself as the Thread
's target. When created in this way, the Thread
gets its run
method from its target. 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: - Subclass the
Thread
class defined in thejava.lang
package and override therun
method.
Example: See theSimpleThread
class described in Subclassing Thread and Overriding run.
- Provide a class that implements the
Runnable
interface (also defined in thejava.lang
package) and therefore implements therun
method. In this case, aRunnable
object provides therun
method to the thread.
Example: See theClock
applet just shown.
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. Download
Download the source code from here. Also see Clock applet here (soon to be added).
No comments:
Post a Comment