Multithreading in Java - Creating Your Own Thread
(Page 4 of 10 )
Remember, your program is the main thread, and other portions of your program can also be a thread. You can designate a portion of your program as a thread by creating your own thread. The easiest way to do this is to implement the Runnable interface. Implementing the Runnable interface is an alternative to your class inheriting the Thread class.
An interface describes one or more method members that you must define in your own class in order to be compliant with the interface. These methods are described by their method name, argument list, and return value.
The Runnable interface describes the method classes needed to create and interact with a thread. In order to use the Runnable interface in your class, you must define the methods described by the Runnable interface.
Fortunately, only you need to define one method described by the Runnable interface—the run() method. The run() method must be a public method, and it doesn’t require an argument list or have a return value.
The content of the run() method is the portion of your program that will become the new thread. Statements outside the run() method are part of the main thread. Statements inside the run() method are part of the new thread. Both the main thread and the new thread run concurrently when you start the new thread, which you’ll learn how to do in the next example. The new thread terminates when the run() method terminates. Control then returns to the statement that called the run() method.
When you implement the Runnable interface, you’ll need to call the following constructor of the Thread class. This constructor requires two arguments. The first argument is the instance of the class that implements the Runnable interface and tells the constructor where the new thread will be executed. The second argument is the name of the new thread. Here’s the format of the constructor:
Thread (Runnable class, String name)
The constructor creates the new thread, but it does not start the thread. You explicitly start the new thread by calling the start()method. The start() method calls the run() method you defined in your program. The start() method has no argument list and does not return any values.
The following example illustrates how to create and start a new thread. Here’s what is displayed when this program runs:
Main thread started
Child thread started
Child thread terminated
Main thread terminated
NOTE: The output of this program may be different when you run this program. Some Java run-time environments terminate the main thread before the child thread, whereas others terminate the child thread before the main thread. Therefore, the text shown here might appear in a different order when you run this program.
class MyThread implements Runnable{
Thread t;
MyThread () {
t = new Thread(this,"My thread");
t.start();
}
public void run() {
System.out.println("Child thread started");
System.out.println("Child thread terminated");
}
}
class Demo {
public static void main (String args[]){
new MyThread();
System.out.println("Main thread started");
System.out.println("Main thread terminated");
}
}
This example begins by defining a class called MyThread, which implements the Runnable interface. Therefore, we use the keyword implements to implement the Runnable interface. Next, a reference to a thread is declared. Defining the constructor for the class follows this. The constructor calls the constructor of the Thread class. Because we are implementing the Runnable interface, we need to pass the constructor reference to the instance of the class that will execute the new thread and the name of the new thread. Notice that we use the keyword this as reference to the instance of the class. The keyword this is a reference to the current instance of the class.
The constructor returns a reference to the new thread, which is assigned to the reference declared in the first statement in the MyThread class definition. We use this reference to call the start() method. Remember that the start() method calls the run() method.
Next,we define the run() method. Statements within the run() method become the portion of the program that executes when the thread executes. There are only two displayed statements in the run() method. Later in this chapter, we’ll expand the run() method to include more interesting statements.
Next, we define the program class. The program class explicitly executes the new thread by creating an instance of the MyThread class. This is done by using the new operator and calling the constructor of MyThread.
Finally, the program finishes by displaying two lines on the screen.
Next: Creating a Thread by Using extends >>
More Java Articles
More By McGraw-Hill/Osborne
|
| · | | | · | | | · | | | · | | | · | | | · | | | · | | | · | | | · | | | · | | | · | | | · | | | · | | | · | | | · | | | · | | | · | | | · | | | · | | | · | | | · | | | · | | | · | | | · | | | · | | | · | | | · | | | · | | | · | | | · | | | · | | | · | | | · | | | · | | | · | | | · | | | · | | | · | | | · | | | · | | | · | | | · | | | · | | | · | | | · | | | · | | | · | | | · | | | | |
|
|
 This article is excerpted from chapter 10 of the book Java Demystified, written by Jim Keogh (McGraw-Hill/Osborne, 2004; ISBN: 0072254548). Check it out at your favorite bookstore today. Buy this book now.
|
|
/ 321 
