Thread Class in Java

Thread Class in Java: Thread Create करने का दूसरा तरीका ये है कि हम Thread Class को Derive करें। उसके बाद Applet Class या किसी Application Class में उस Extended Thread Class का एक Object Create करें और उस Thread को Run करने के लिए उसके लिए start() Method Call करें। Applet Class में Thread Object को Applet के Data व Methods को Access करने की सुविधा देने के कारण एक Applet व एक Thread आपस में आसानी से Communication कर पाते हैं, जिससे Applet व Thread दोनों ही समानान्तर रूप से Run हो पाते हैं।

हम हमारी Class को java.lang.Thread Class से Extend करके एक Runnable Thread की तरह Define कर सकते हैं। जब हम Thread Class को ही Extend करके एक नई Thread Class बनाना चाहते हैं, तब ऐसा करने के लिए हमें निम्न Steps Follow करने होते हैं:

• नई Thread Class को lang.Thread Class से Extend करें।
• Thread Class के run() Method को Implement करें, जो कि किसी भी Thread के Executable Codes को Execute करने के लिए जिम्मेदार होता है।
• अब इस Extended Class का एक Thread Object Create करें और इसके लिए start() Method को Call करके Thread को Start करें।

चलिए, इन Steps को थोडा और समझते हैें:

Declaring the Class

एक नए Thread को Create करने के लिए हम Thread Class को निम्नानुसार Extend कर सकते हैं:

	class MyThread extends Thread	{
		// Thread Codes goes here.
		. . .
		// run() Method Implementation code goes here.
	}

इस प्रकार Thread को Extend करने पर हमारे पास MyThread नाम का एक और Thread Class होता है, जिसके Objects Create किए जा सकते हैं।

Implementing the run() Method

जब Thread Class को Extend करते हैं, तब इसका run() Method भी Inherit हो जाता है। हमें इस Method को Override करना होता है और इस Method में वे Codes लिखने होते हैं, जो Thread के Execution के साथ ही Execute होने चाहिएं। run() Method का Basic Implementation हमें निम्नानुसार दिखाई देता है:

	class MyThread extends Thread
	{
		// Thread Codes goes here.
		. . .
			
		run()
		{
			// Implementation code goes here.
		}
	}

चूंकि, जब जावा किसी नए Thread को Start करता है, तो वह उस Thread के इसी run() Method को Call करता है, इसलिए किसी Thread द्वारा हमें जो भी काम करवाने होते हैं, उन्हें इसी Method में Define करते हैं।

Starting New Thread

किसी Thread को Run करने के लिए हमें उस Thread को Extend करने के बाद उस Thread का Object Create करना होता है और उस Object के लिए start() Method को Call करना होता है। उदाहरण के लिए मानलो कि हमें MyThread Class का Object Create करके उसे Run करना है। इसके लिए हमें निम्नानुसार Code लिखना होता है:

        MyThread myNewThread = new MyThread();

        myNewThread.start();

इस Code की पहली Line MyThread Class का एक Object Create करता है। जो Thread इस Object को Run करेगा वह Object अभी Run नहीं हो रहा है। यानी ये Thread अभी Newborn State में है। इस Code Segment की दूसरी Line में Thread Object के साथ start() Method को Call किया गया है। start() Method myNewThread Object को Runnable State में ले जाता है, जिसमें Thread का run() Method Execute होने लगता है और Thread Runnable State में आ जाता है।

start() Method एक ऐसा Method है जो किसी Main Thread में Run किए जाने वाले किसी दूसरे Thread के run() Method को Invoke करके तुरन्त फिर से Main Method में आ जाता है और Main Method के अगले Statement का Execution कर देता है। इस प्रक्रिया को हम निम्नानुसार एक उदाहरण द्वारा समझ सकते हैं:

// Program
// File Name : ExtededThreadUsingApplication.java
	
class FirstThread extends Thread
{
	public void run()
	{
		for(int i=0; i<5; i++)
		{
			try
			{
				System.out.println("In FirstThread i = : " + i);
				Thread.sleep(1);
			}
			catch(InterruptedException e)
			{
				System.out.println("Another Thread Interrupted");
			}
		}
	System.out.println("Exiting from FirstThread \n");
	}
}
	
class SecondThread extends Thread
{
	public void run()
	{
		for(int i=0; i<5; i++)
		{
			try
			{
				System.out.println("In SecondThread i = : " + i);
				Thread.sleep(2);
			}
			catch(InterruptedException e)
			{
				System.out.println("Another Thread Interrupted");
			}
		}
	System.out.println("Exiting from SecondThread \n");
	}
}

class ThirdThread extends Thread
{
	public void run()
	{
		for(int k=0; k<5; k++)
		{
			System.out.println("In ThirdThread k = : " + k);
		}
	System.out.println("Exiting from ThirdThread \n");
	}
}
	
public class ExtededThreadUsingApplication 
{
    public static void main(String args[])
    {
		new FirstThread().start();
		new SecondThread().start();
		new ThirdThread().start();
    }
}

// Output 
   In FirstThread i = : 0
   In SecondThread i = : 0
   In ThirdThread k = : 0
   In ThirdThread k = : 1
   In ThirdThread k = : 2
   In ThirdThread k = : 3
   In ThirdThread k = : 4
   Exiting from ThirdThread

   In FirstThread i = : 1
   In SecondThread i = : 1
   In FirstThread i = : 2
   In SecondThread i = : 2
   In FirstThread i = : 3
   In FirstThread i = : 4
   In SecondThread i = : 3
   Exiting from FirstThread

   In SecondThread i = : 4
   Exiting from SecondThread

इस Program मे हमने Thread Class को तीन Sub Classes में Inherit किया है और तीनों ही Classes में Thread Class के run() Method को Implement करके उसमें Sub Program के Codes लिखे हैं। तीनों ही Thread आपस में Swap हो सकें, इसलिए तीनों ही Threads में sleep() Method का प्रयोग करके Threads को 1 Millisecond के लिए Sleep Mode में भेजा है।

चूंकि sleep() Method उस समय एक Exception Throw करता है, जब कोई दूसरा Thread पहले Thread को Interrupt करता है। इसलिए sleep() Method को हमेंशा हम try/catch Block में लिखते हैं।

Thread Exception

sleep() Method एक Exception Throw करता है। यदि हम इस Exception को Catch ना करें, तो हमारा Program Compile नहीं होता है। कोई Thread जब Suspend Mode में होता है, तब वह किसी Method को Invoke करने की स्थिति में नहीं होता है। यदि उस समय हम उस Thread से किसी Method को Invoke करवाते हैं, तो sleep() Method IllegalThreadStateException Throw करता है।

उदाहरण के लिए यदि कोई Thread Sleep Mode में हो तो वह resume() Method को Invoke नहीं कर सकता है। क्योंकि कोई Sleeping Thread कोई भी Instruction Execute करने में सक्षम नहीं होता है। यही स्थिति suspend() Method के सम्बंध में भी होती है।

यदि हम ऐसे Method को Call कर रहे हैं, जो Exception Throw कर सकता है, तो हमें उसके Exception को Handle करना जरूरी होता है। इसके लिए हमें Appropriate Exception Handler लिखना होता है। एक Exception Handler के catch Block का निम्न में से कोई रूप हो सकता है:

	catch(ThreadDeath excp )
	{
		. . .
		. . .				// Killed Thread
	}
	
	catch(InterruptedException excp )
	{
		. . .
		. . .				// Killed Thread
	}
	
	catch(IllegalArgumentException excp )
	{
		. . .
		. . .				// Killed Thread
	}
	
	catch(Exception excp )
	{
		. . .
		. . .				// Killed Thread
	}