Creating a Thread - Java

In the most general sense, you create a thread by instantiating an object of type Thread. Java defines two ways in which this can be accomplished:

Creating
a Thread

In the most general sense,
you create a thread by instantiating an object of type Thread. Java defines two ways in which this can be accomplished:

You can implement the Runnable
interface.

You can extend the Thread
class, itself.

The following two sections
look at each method, in turn.

Implementing
Runnable

The easiest way to create a
thread is to create a class that implements the Runnable interface. Runnable
abstracts a unit of executable code. You can construct a thread on any object
that implements Runnable. To
implement Runnable, a class need
only implement a single method called run(
), which is declared like this:

public void run( )

Inside run( ), you will define the code that constitutes the new thread.
It is important to understand that run(
) can call other methods, use other classes, and declare variables, just
like the main thread can. The only difference is that run( ) establishes the entry point for another, concurrent thread
of execution within your program. This thread will end when run( ) returns.

After you create a class that
implements Runnable, you will
instantiate an object of type Thread from
within that class. Thread defines
several constructors. The one that we will useis shown here:

Thread(Runnable threadOb, String threadName)

In this constructor, threadOb is an instance of a class that
implements the Runnable interface.
This defines where execution of the thread will begin. The name of the new
thread is specified by threadName.

After the new thread is
created, it will not start running until you call its start( ) method, which is declared within Thread. In essence, start( )
executes a call to run( ). The start( ) method is shown here:

void start( )

Here is an example that
creates a new thread and starts it running:

// Create a second thread.

class NewThread implements Runnable { Thread t;

NewThread() {

// Create a new, second thread

t = new Thread(this, "Demo Thread");

System.out.println("Child thread: " + t);

t.start(); // Start the
thread

}

// This is the entry point for the second
thread.

public void run() {

try {

for(int i = 5; i > 0; i--) {

System.out.println("Child Thread: " + i);

Thread.sleep(500);

}

} catch (InterruptedException e) {

System.out.println("Child interrupted.");

}

System.out.println("Exiting child
thread.");

}

class ThreadDemo {

public static void main(String args[ ] ) {

new NewThread(); // create a new thread

try {

for(int i = 5; i > 0; i--) {

System.out.println("Main Thread: " +
i);

Thread.sleep(1000);

}

} catch (InterruptedException e) {

System.out.println("Main thread
interrupted.");

}

System.out.println("Main thread
exiting.");

}

}

Inside NewThread’s constructor, a new Thread
object is created by the following statement:

t = new Thread(this, "Demo Thread");

Passing this as the first argument indicates that you want the new thread
to call the run( ) method on this object. Next, start( ) is called, which starts the thread of execution beginning
at the run( ) method. This causes
the child thread’s for loop to
begin. After calling start( ), NewThread’s constructor returns to main( ). When the main thread resumes,
it enters its for loop. Both threads
continue running, sharing the CPU in single-core systems, until their loops finish.
The output produced by this program is as follows. (Your output may vary based
upon the specific execution environment.)

Child thread: Thread[Demo Thread,5,main]

Main Thread: 5

Child Thread: 5

Child Thread: 4

Main Thread: 4

Child Thread: 3

Child Thread: 2

Main Thread: 3

Child Thread: 1

Exiting child thread.

Main Thread: 2

Main Thread: 1

Main thread exiting.

As mentioned earlier, in a
multithreaded program, often the main thread must be the last thread to finish
running. In fact, for some older JVMs, if the main thread finishes before a
child thread has completed, then the Java run-time system may “hang.” The
preceding program ensures that the main thread finishes last, because the main
thread sleeps for 1,000 milliseconds between iterations, but the child thread
sleeps for only 500 milliseconds. This causes the child thread to terminate
earlier than the main thread. Shortly, you will see a better way to wait for a
thread to finish.

Extending
Thread

The second way to create a
thread is to create a new class that extends Thread, and then to create an instance of that class. The extending
class must override the run( )
method, which is the entry point for the new thread. It must also call start( ) to begin execution of the new
thread. Here is the preceding program rewritten to extend Thread:

// Create a second thread by extending Thread

class NewThread extends Thread {

NewThread() {

// Create a new, second thread

super("Demo
Thread");

System.out.println("Child thread: " +
this);

start(); // Start the thread

}

// This is the entry point for the second
thread.

public void run() {

try {

for(int i = 5; i > 0; i--) {

System.out.println("Child Thread: " + i);

Thread.sleep(500);

}

} catch (InterruptedException e) {

System.out.println("Child interrupted.");

}

System.out.println("Exiting child
thread.");

}

}

class ExtendThread {

public static void main(String args[]) { new
NewThread(); // create a new thread

try {

for(int i = 5; i > 0; i--) {
System.out.println("Main Thread: " + i);

Thread.sleep(1000);

}

} catch (InterruptedException e) {

System.out.println("Main thread interrupted.");

}

System.out.println("Main thread
exiting.");

}

}

This program generates the
same output as the preceding version. As you can see, the child thread is created
by instantiating an object of NewThread,
which is derived from Thread.

Notice the call to super( ) inside NewThread. This invokes the following form of the Thread constructor:

public Thread(String threadName)

Here, threadName specifies the name of the thread.

Choosing
an Approach

At this point, you might be
wondering why Java has two ways to create child threads, and which approach is
better. The answers to these questions turn on the same point. The Thread class defines several methods
that can be overridden by a derived class. Of thesemethods, the only one that must
be overridden is run( ). This is, of
course, the same method required when you implement Runnable. Many Java programmers feel that classes should be
extended only when they are being enhanced or modified in some way. So, if you
will not be overriding any of Thread’s
other methods, it is probably best simply to implement Runnable. Also, by implementing
Runnable, your thread class does not need to inherit Thread, making it free to inherit a different class. Ultimately,
which approach to use is upto you.
However, throughout the rest of this chapter, we will create threads by using
classes that implement Runnable.