When a thread object is created, it is not "runnable" at that time. The thread has all the resources it requires to be runnable but will only do so after a call to its start() method is made. This causes the scheduler to call the thread's run method.

It is likely that many threads will be in a "runnable" state simultaneously. For a single CPU all threads compete for the CPU and (hopefully) eventually get to run. Contrast this to the multiprocessor case, where several threads could run in parallel. From a design point of view it is reasonable to assume that any "runnable" thread can run at any time.

A running thread can voluntarily give up the processor by calling yield(). It can also call sleep() if it wishes to stop for a specific amount of time.

A "runnable" thread can block for a number of reasons:

A thread can die for one of two reasons:

Threads and the Runnable Interface

There are two ways to create a thread class:

The obvious way to create a new thread class is to extend the Thread class and override the run() method. This does not work if it is necessary to extend another class (such as an applet class — Java supports multiple inheritance of interfaces, not classes). Any class can implement the Runnable interface while extending another class. The Runnable interface is defined as:

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

A class that implements an interface must implement all the methods defined in that interface, so a class that implements the Runnable interface must define a run() method.

When the thread's start() method is called, the Java Virtual Machine calls the thread's run() method. The code in the run() method is the only code that runs as a separate thread.

Threads and Applets

In this section we will examine the use of threads to run applets. First we write an applet class and then write a thread class. The code demonstrates the running of applets as threads.

   public class sampleApplet extends Applet implements Runnable {

   private Thread thread; /* define a private reference to Thread */

   public void start() {

     thread = new Thread(this); /* create a new thread */
     thread.start(); /* make this thread runnable */
   }

   public void run() {

     /* this method will run on a separate thread */

   }

   } /* End of this class */

   public class Thread implements Runnable {

   private Runnable target;

   public Thread(Runnable foo) {

     target = foo; /* constructor for this class */

   }

   public void run() {
     if (target != null)
     target.run();
   }

   } /* End of this class */

In the above example we show how an applet class can implement the Runnable interface. The start() method of the applet creates a new thread by calling the constructor that takes a reference to the target Runnable object — in other words, a reference to an object that provides the run() method. In this case, the run() method is defined in the applet itself, so the start() method passes this (a reference to itself) to the Thread constructor. The Thread constructor stores this reference in an instance variable called target. The start() puts the new Thread object into a "runnable" state by calling the start() method.

When a Thread object enters the "runnable" state, it becomes a candidate for scheduling. The first time it is scheduled, the scheduler calls its run() method; the run() method checks to see if the target class is not equal to null and then calls the run() method of the target object, that is, the run() method in sampleApplet. This allows sampleApplet to be run in separate threads. The body of the run() method will usually be an infinite loop. (Remember, you exit the thread if you return from run().)

Controlling a Thread

A thread can be "blocked" temporarily by calling its suspend() and resume() methods. The following shows a code segment to do this.

   boolean stopped;

   public boolean mouseDown(Event x) {

    if (stopped)
     thread.resume();
    else
     thread.suspend();
     stopped = !stopped;
    return true;
   }

A thread can put itself to sleep for a specified amount of time by calling its sleep method and passing to it the time (in milliseconds) of the sleep duration.

Thread.sleep(long time);

This is useful to do in tight loops to prevent the thread from "hogging" the CPU. This may throw an InterruptedException, so there needs to be code to catch this exception.

Threads can be terminated by calling stop(). This throws a ThreadDeath object, and this must also be handled. All cleanup from a thread exiting can be done in the "finally" clause of the object.

An Applet Example

The following example displays a running count in an applet window.

   public class Counter extends Applet implements Runnable {
    private Thread thread;

    private int count; ; /* set up a counter */

    public void start() {
     if (thread == null) {
      thread = new Thread(this); /* target = this */
      thread.start();
    }
   }

    public void stop() { /* stop this thread */
     thread.stop();
     thread = null;
}

    public void run() {
     while (true) {
      count++; /* increment the count */
      repaint(); /* request screen refresh */

     try {
      Thread.sleep(10); /* sleep for 10 ms */
     } catch (InterruptedException e) {}
    }
   }
    public void paint(Graphics g) { /* display the count */
     g.drawString("Count = " + count, 10, 10);
    }
   }

In this example, the applet's start() method checks the value of the instance variable thread to see if it has already been created; if not, the start() method creates it and passes the this parameter to the thread's constructor. The run() method in the Thread object calls the run() method in this applet.

After the Thread object is created, a call is made to its start() method. Once this method returns, the applet's start() method returns control to the browser. In the meantime, the new thread will start executing the applet's run() method. If there was no call to sleep(), the thread could potentially hog the CPU and not relinquish it, causing starvation for other threads.

Creating Multiple Threads

We can create multiple threads by putting the run() method in a class of its own.

public class Counter implements Runnable {
  private TextField foo;
  private int count;

  public Counter(TextField t) {
   foo = t;
  }

  public void run() {
   while (true) {
    count++;
   txt.setText(count);
   .......
  }
 }
}

public class CounterTest extends Applet {
  private TextField x1, x2;
  private Counter y1, y2;

  public void start() {

   y1 = new Counter(x1);
   y2 = new Counter(x2);
   new Thread(y1).start();
   new Thread(y2).start();

 }

}

A class can contain only one run() method, so if an applet needs to create more than one thread and each thread needs to be different, then each run() method must be in a class of its own. Any class can implement the Runnable interface, so this is not a problem. In the example above, the Counter class displays the running count in a TextField component. The constructor initializes the instance variable to refer to a TextField object. The run() method is similar to that in the previous example, except that the count is displayed in the TextField component.

The CounterTest class (an applet) can create as many Counter objects as required. In this example there are two such threads. The init() method for this class is shown below; it creates the TextField components and adds them to the applet window.

 public void init() {
  x1 = new TextField(24);
  x2 = new TextField(24);
  add(x1);
  add(x2);
 }

A separate Thread object must be associated with each Counter object. Consequently, when the Thread objects are created, we pass the reference to the appropriate Counter object to the Thread constructor. Then we call the thread's start() method. After the second Thread object is created, control is returned to the browser. In the meantime, the two TextField components will display a running count.

Conclusion

The simplicity with which a novice Java programmer can create multithreaded applications is an appealing feature of this language. In this article we have presented a brief tutorial on threads in Java. I consider this brief because although we examined some fundamental aspects of using threads, the complexity associated increases in a nonlinear fashion as you scale the number of threads in your application. Add to this the fact that assigning priorities is not a trivial design task, and thread synchronization adds yet another level of complexity. It is important to understand threads as they have been presented here before embarking on the other fronts.

In future articles, to demonstrate their capabilities, we will examine thread priorities and synchronization in the context of other applications.