Thread Creation
In Java, an object of the Thread
class can represent a thread. Thread can be implemented through any one of two ways:
- Extending
the java.lang.Thread Class
- Implementing
the java.lang.Runnable Interface
I.
Extending
the java.lang.Thread Class
For creating a thread a class have to
extend the Thread Class. For creating a thread by this procedure you have to
follow these steps:
- Extend
the java.lang.Thread Class.
Override
the run( ) method in the subclass from the Thread class to define the code
executed by the thread.
Create
an instance of this subclass. This subclass may call a Thread class
constructor by subclass constructor.
Invoke
the start( ) method on the instance of the class to make the thread eligible
for running.
The following program demonstrates
a single thread creation extending the "Thread" Class:
class MyThread extends Thread{
String s=null;
MyThread(String s1){
s=s1;
start();
}
public void run(){
System.out.println(s);
}
}
public class RunThread{
public static void main(String args[]){
MyThread m1=new MyThread("Thread started....");
}
}
|
Output of the Program is :
C:\j2se6\thread>javac
RunThread.java
C:\j2se6\thread>java RunThread
Thread started....
|
Download this example
II. Implementing the java.lang.Runnable Interface
The procedure for creating threads by implementing the
Runnable Interface is as follows:
- A
Class implements the Runnable Interface, override the run() method
to define the code executed by thread. An object of this class is
Runnable Object.
- Create
an object of Thread Class by passing a Runnable object as argument.
- Invoke the start( ) method on the instance of the Thread
class.
The following program demonstrates
the thread creation implenting the Runnable interface:
class MyThread1 implements Runnable{
Thread t;
String s=null;
MyThread1(String s1){
s=s1;
t=new Thread(this);
t.start();
}
public void run(){
System.out.println(s);
}
}
public class RunableThread{
public static void main(String args[]){
MyThread1 m1=new MyThread1("Thread started....");
}
}
|
However, this program returns the output same as
of the output generated through the previous program.
Output of the Program is:
C:\j2se6\thread>javac
RunableThread.java
C:\j2se6\thread>java RunableThread
Thread started....
|
Download this
example
There are two reasons for
implementing a Runnable interface preferable to extending the Thread Class:
- If
you extend the Thread Class, that means that subclass cannot extend any
other Class, but if you implement Runnable interface then you can do this.
- The
class implementing the Runnable interface can avoid the full overhead of
Thread class which can be excessive.
join() &
isAlive() methods:
The following
program demonstrates the join() & isAlive() methods:
class DemoAlive extends Thread {
int value;
public DemoAlive(String str){
super(str);
value=0;
start();
}
public void run(){
try{
while (value < 5){
System.out.println(getName() + ": " + (value++));
Thread.sleep(250);
}
} catch (Exception e) {}
System.out.println("Exit from thread: " + getName());
}
}
public class DemoJoin{
public static void main(String[] args){
DemoAlive da = new DemoAlive("Thread a");
DemoAlive db = new DemoAlive("Thread b");
try{
System.out.println("Wait for the child threads to finish.");
da.join();
if (!da.isAlive())
System.out.println("Thread A not alive.");
db.join();
if (!db.isAlive())
System.out.println("Thread B not alive.");
} catch (Exception e) { }
System.out.println("Exit from Main Thread.");
}
}
|
Output
of this program is:
C:\j2se6\thread>javac DemoJoin.java
C:\j2se6\thread>java DemoJoin
Wait for the child threads to finish.
Thread a: 0
Thread b: 0
Thread a: 1
Thread b: 1
Thread a: 2
Thread b: 2
Thread a: 3
Thread b: 3
Thread a: 4
Thread b: 4
Exit from thread: Thread a
Thread A not alive.
Exit from thread: Thread b
Thread B not alive.
Exit from Main Thread.
C:\j2se6\thread> |
Download
this example
|
Del.icio.us
Digg
Google
Spurl
Blink
Furl
Simpy
Y! MyWeb
