Home arrow Java arrow Page 4 - Multithreading in Java
JAVA

Multithreading in Java


Multithreading allows two parts of the same program to run concurrently. This article discusses how to pull off this performance-improving feat in Java. It is excerpted from chapter 10 of the book Java Demystified, written by Jim Keogh (McGraw-Hill/Osborne, 2004; ISBN: 0072254548).

Author Info:
By: McGraw-Hill/Osborne
Rating: 4 stars4 stars4 stars4 stars4 stars / 535
August 04, 2005
TABLE OF CONTENTS:
  1. · Multithreading in Java
  2. · Overhead
  3. · The Thread Classes and the Runnable Interface
  4. · Creating Your Own Thread
  5. · Creating a Thread by Using extends
  6. · Using isAlive() and join()
  7. · Setting Thread Priorities
  8. · Synchronizing Threads
  9. · Using the Synchronized Statement
  10. · Suspending and Resuming Threads

print this article
SEARCH DEVARTICLES

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.


blog comments powered by Disqus
JAVA ARTICLES

- Java Too Insecure, Says Microsoft Researcher
- Google Beats Oracle in Java Ruling
- Deploying Multiple Java Applets as One
- Deploying Java Applets
- Understanding Deployment Frameworks
- Database Programming in Java Using JDBC
- Extension Interfaces and SAX
- Entities, Handlers and SAX
- Advanced SAX
- Conversions and Java Print Streams
- Formatters and Java Print Streams
- Java Print Streams
- Wildcards, Arrays, and Generics in Java
- Wildcards and Generic Methods in Java
- Finishing the Project: Java Web Development ...

Watch our Tech Videos 
Dev Articles Forums 
 RSS  Articles
 RSS  Forums
 RSS  All Feeds
Write For Us 
Weekly Newsletter
 
Developer Updates  
Free Website Content 
Contact Us 
Site Map 
Privacy Policy 
Support 

Developer Shed Affiliates

 




© 2003-2017 by Developer Shed. All rights reserved. DS Cluster - Follow our Sitemap
Popular Web Development Topics
All Web Development Tutorials