Thread Life Cycle in Java

Thread Life Cycle in Java: हमने पिछले दो उदाहरणों में ये समझा कि किस प्रकार से किसी Sub Program को एक Thread के रूप में Convert करके समानान्तर रूप से Execute किया जा सकता है, लेकिन अभी तक हमने ये नहीं जाना है कि विभिन्न Threads Java-Thread-States में किस प्रकार से Run होते हैं। हम जो भी Thread Create करके Thread Object के रूप में Represent करते हैं, वे सभी Threads अपनी Life-Cycle में एक निश्चित Thread States में Travers करते हैं। कोई भी जावा Thread मु[तया पांच Thread States में Traverse करता है। वे स्थितियां निम्नानुसार हैं:

• NEWBORN State
• RUNNABLE State
• RUNNING State
• BLOCKED State
• DEAD State

NEWBORN State

जब हम सबसे पहले एक नया Thread Object Create करते हैं, तब Create होने वाले Thread को NEWBORN State का Thread कहा जाता है, क्योंकि इस Thread को Run होने के लिए अभी तक Schedule नहीं किया गया होता है। कोई नया Thread Object Create करने के लिए हम निम्नानुसार Code Statement लिखते हैं:

      Thread newThreadObject = new Thread(this);

इस Statement में this Object बताता है कि Thread को Run करने के लिए run() Method को Current Object के लिए Call करना होगा और यदि हम इस Thread को Terminate करना चाहते हैं, तो Thread को Terminate करने के लिए stop() Method को भी हमें इसी Object के लिए Call करना होगा।

यानी हमें Thread के साथ जिस किसी भी प्रकार का भी काम करना है, उस काम को Perform करने वाले Method को इसी Object के साथ Call करना होगा। जब हम सबसे पहले कोई नया Thread Object Create करते हैं, तब हम इस Object के साथ निम्न में से ही कोई Method Call कर सकते हैं:

• start() Method का प्रयोग करके इसे Run करने के लिए Schedule कर सकते हैं।
• stop() Method का प्रयोग करके Thread को Terminate कर सकते हैं।

यदि हम Thread को Schedule करते हैें, तो Thread RUNNABLE State में Move हो जाता है। यदि Thread Create करने के बाद उस Thread Object के साथ start() या stop() Method के अलावा कोई अन्‍य Method Call करते हैं, तो इस Stage में एक Exception Throw किया जाता है। पिछला Code Statement एक Thread Object Create करता है, लेकिन अभी तक इस Thread Object को किसी प्रकार का कोई Resource Allocate नहीं किया गया है। अभी तक ये एक Empty Object होता है। इसलिए इस Thread को Start करने के लिए हमें start() Method को Call करना होता है। ये काम हम निम्नानुसार Statement द्वारा करते हैं:

      newThreadObject.start();

यदि हम Thread को Start करना ना चाहें, तो ;हीं पर stop() Method को Call करके Thread को निम्नानुसार Terminate भी कर सकते हैं:

        newThreadObject.stop();

RUNNABLE State

इस State का मतलब ये है कि Thread Execute होने के लिए तैयार है और CPU का Attention प्राप्त करने का इन्तजार कर रहा है। चूंकि एक Single Processor Computer System पर एक ही CPU होता है और एक CPU एक समय में केवल एक ही Statement को Execute कर सकता है। इसलिए एक Single Processor CPU पर Multithreaded Programming को Maintain करने के लिए एक Thread Queue का प्रयोग किया जाता है।

जब हम नया Thread Create करते हैं, तब Threads के Queue में हमारा Thread Queued Up हो जाता है और Execute होने का Wait करता है। यदि Threads के Queue में उपस्थित सभी Threads को समान Priority प्राप्त हो, तो सभी Threads को Execute होने के लिए जावा द्वारा Round-Robin Fashion में CPU पर Time Slot प्रदान किया जाता है।

इस Fashion में जो Thread पहले आता है, वह पहले Process होता है। जो Thread थोडे समय के लिए Suspend Mode में जाता है, वह Thread फिर से Threads के Queue के अन्त में Join हो जाता है और फिर से CPU पर अपने Execution का Wait करता है। विभिन्न Threads को Time Assign करने का ये तरीका Time-Slicing Method कहलाता है।

एक Thread Queue में विभिन्न Priority वाले Threads Execution के लिए उपलब्ध हो सकते हैं। यदि हम चाहते हैं कि कोई Thread फिर से अपना Turn आने से पहले अपना Control समान Priority वाले दूसरे Running Thread को Hand-Over करे, तो इस काम को करने के लिए हमें yield() Method का प्रयोग करना होता है।

RUNNIG State

RUNNING State का मतलब है कि CPU ने Thread को अपना Time दे दिया है और Thread Run हो रहा है। Thread तब तक RUNNING State में रहता है, जब तक कि वह अपना Control किसी दूसरे Thread को Transfer नहीं कर देता या फिर किसी High Priority Thread द्वारा Thread के Execution को Prevent नहीं कर दिया जाता। एक RUNNING State का Thread अपना Control निम्न स्थितियों में किसी दूसरे Thread को Hand Over करता है:

1. जब Thread suspend() Method के प्रयोग द्वारा Suspend किया जाता है, तब वह Thread किसी दूसरे Thread को अपना Control Hand Over करता है। Suspended Thread को फिर से Retrieve करने के लिए resume() Method का प्रयोग किया जाता है। ये Approach तब Use किया जाता है जब हम किसी Thread को किसी कारण से कुछ समय के लिए Suspend तो करना चाहते हैं, लेकिन उसे Permanently Terminate करना नहीं चाहते हैं।

2. हम एक Thread को sleep() Method का प्रयोग करके भी Suspend Mode में लाते हैं। जब हम sleep() Method का प्रयोग करके किसी Thread को थोडे समय के लिए Suspend Mode में लाना चाहते हैं, तब जितने समय के लिए Thread को Suspend करना चाहते हैं, उतना समय Milliseconds के रूप में sleep() Method में Argument के रूप में Pass करते हैं। हम इस Method में Argument के रूप में जितना समय Specify करते हैं, उतना समय बीतते ही वह Thread फिर से RUNNABLE State में आ जाता है।

3. तीसरे तरीके में किसी Thread को किसी Event के Generate होने तक Wait करने के लिए कहा जाता है। जितने समय तक वह Thread किसी Event के Generate होने का Wait करता है, उतने समय तक Thread Suspend Mode में रहता है। किसी Thread को जब किसी Event का Wait करने के लिए Suspend Mode में भेजना होता है, तब हमें wait() Method का प्रयोग करना पडता है। Thread को फिर से RUNNABLE State में लाने के लिए notify() Method का प्रयोग किया जाता है।

BLOCKED State

एक Thread को जब RUNNABLE State में आने से रोका जाता है, तब वह Thread BLOCKED State में होता है। जब कोई Thread किसी जरूरत को पूरा करने के लिए Suspend, Sleeping या Waiting Mode में होता है, तब वह Thread BLOCKED State में होता है। एक BLOCKED State का Thread “NOT RUNNABLE” State में होता है लेकिन वह Thread DEAD State में नहीं होता है। यानी एक BLOCKED State का Thread RUNNABLE State में आने में सक्षम होता है।

DEAD State

हर Thread का एक Life Cycle होता है। जिस किसी भी Thread के run() Method का Execution हो जाता है, वह Thread उसकी Natural DEAD State में पहुंच जाता है। फिर भी हम किसी भी समय अपनी जरूरत के अनुसार किसी भी RUNNING Thread को DEAD State में भेज सकते हैं।

किसी Thread को DEAD State में भेजने के लिए हमें उस Thread के लिए stop() Method को Call करना होता है। किसी Thread को जब वह RUNNING State में होता है या जब वह BLOCKED State में होता है या जब वह NEWBORN State में होता है, उसे किसी भी समय DEAD State में भेजा जा सकता है।

जब हम किसी Thread को एक बार stop() Method द्वारा DEAD State में भेज देते हैं, तो फिर से उस Thread को RUNNING State में नहीं ला सकते हैं और उस Thread के लिए किसी भी Thread Method को Call नहीं कर सकते हैं।

// Program
// File Name : ThreadMethods.java
	
class NewThread extends Thread{
	public void run(){
		System.out.println("New Thread Started");

		for(int i=1; i<=5; i++)	{
			System.out.println("\t From NewThread i =" + i);

			if(i==1)
				yield();
		}
		System.out.println("Exit From NewThread");
	}
}
	
class MidThread extends Thread
{
	public void run(){
		System.out.println("Mid Thread Started");
		for(int i=1; i<=5; i++)	{
			System.out.println("\t From MidThread i =" + i);

			if(i==3)
				stop();

		}
		System.out.println("Exit From MidThread");
	}
}
	
class OldThread extends Thread{
	public void run(){
		System.out.println("Old Thread Started");
		for(int i=1; i<=5; i++)
		{
			if(i==1)
			try{
				sleep(1000);
			}
			catch(Exception excp){}

			System.out.println("\t From OldThread i =" + i);
		}
		System.out.println("Exit From OldThread");
	}
}

public class ThreadMethods{
	public static void main(String args[]){
		NewThread newThread = new NewThread();
		MidThread midThread = new MidThread();
		OldThread oldThread = new OldThread();
		System.out.println("New Thread Started");
		newThread.start();
		System.out.println("Mid Thread Started");
		midThread.start();
		System.out.println("Old Thread Started");
		oldThread.start();
		System.out.println("End of the Main Thread");
	}
}

//Output 
	New Thread Started
   Mid Thread Started
   New Thread Started
         From NewThread i =1
   Old Thread Started
   End of the Main Thread
         From NewThread i =2
         From NewThread i =3
         From NewThread i =4
         From NewThread i =5
   Exit From NewThread
   Mid Thread Started
         From MidThread i =1
         From MidThread i =2
         From MidThread i =3
   Old Thread Started
         From OldThread i =1
         From OldThread i =2
         From OldThread i =3
         From OldThread i =4
         From OldThread i =5
   Exit From OldThread

जब yield() Method को Use किया जाता है, तब ये Method Java Runtime में Current Thread को Sleep Mode में भेज देता है और Thread के Queue में स्थित अगले Thread को Control Transfer कर देता है। जब हम इस Method का प्रयोग करते हैं, तब चाहे Thread Queue में Low Priority का ही Method क्यों ना हो, वह Execute होता है और उसे CPU का Attention प्राप्त होता है।

इस Program में हमने yield() Method का प्रयोग किया है। हालांकि newThread Object का Execution पहले शुरू होता है, फिर भी जैसे ही Loop के Variable i का मान 1 होता है, Condition True हो जाती है और ये Thread अपना Control oldThread Object को Pass कर देता है, क्योंकि इस Thread के बाद oldThread ही Start होता है।

oldThread के Start होते ही वह 1 Second के लिए Suspend Mode में चला जाता है, इसलिए Control फिर से newThread में Pass हो जाता है और newThread का सारा काम पूरा होने के बाद Control midThread में पहुंचता है। वहां पर Loop तीन बार चलता है और जैसे ही i का मान 3 होता है, ये Thread Terminate हो जाता है। फिर यहां से Control oldThread में पहुंचता है और वहां के सभी Statements का Execution कर देता है।