Java Thread Priority

Java Thread Priority: आप सोंच सकते हैं कि एक ही Single CPU वाले Computer System पर Multithreaded Programming कैसे सम्भव हो पाती है। क्योंकि एक Computer System में केवल एक ही CPU होता है और एक CPU एक समय में केवल एक ही Computer Instruction को Execute कर सकता है।

इसका मतलब ये हुआ कि हम किसी Program को चाहे जितने Sub Programs में विभाजित कर लें, CPU एक समय में केवल एक ही काम करने में सक्षम होगा। वास्तव में एक Simple CPU वाला Computer एक समय में केवल एक ही काम करता है, लेकिन Multithreading में एक ही Program के विभिन्न Sub Programs के एक-एक Instruction को CPU पर Process होने के लिए भेजा जाता है, इसलिए हमें ऐसा लगता है, जैसे सभी Sub Programs समानान्तर रूप से Run हो रहे हैं।

चलिए, समझने की कोशिश करते हैं कि एक Single CPU वाले Computer System पर Multithreading Programming को किस प्रकार से सम्भव बनाया जाता है।

किसी Single CPU वाले System पर Parallel Thread Execution को सम्भव बनाने के लिए हर Thread को ये Opportunity प्रदान की जाती है कि Regular Intervals पर विभिन्न Threads के Codes में से थोडा सा Code Execute हो जाता है। इस Approach को Time-Slicing कहा जाता है, जिसमें हर Thread को CPU का थोडा सा समय मिल जाता है।

चूंकि एक Single CPU भी एक Second में करोडों Instructions को Execute करने में सक्षम होता है, इसलिए हम जब एक ऐसे Program को Run करते हैं, जिसमें एक Program विभिन्न Threads में विभाजित होता है और हर Thread के Codes का कुछ हिस्सा समय&समय पर एक Regular Intervals के बाद Execute होता रहता है, तो हमें ऐसा लगता है, जैसे एक ही समय में एक साथ कई काम Parallel Form में Perform हो रहे हैं। किसी Program के विभिन्न Threads कितने&कितने समय के लिए CPU का Attention प्राप्त कर सकते हैं, ये तय करने की प्रक्रिया को Scheduling कहा जाता है।

अभी तक हमने जितने भी Programs बनाए हैं, उनमें सभी Threads को लगभग समान समय प्रदान किया गया है और CPU हर Thread को समान Attention देता है। लेकिन परिस्थितियां हमेंशा ऐसी नहीं होती हैं, जहां सभी Threads को CPU से समान समय प्राप्त हो।

कई बार परिस्थितियां ऐसी होती हैं, जिसमें किसी Thread को CPU के ज्यादा Attention की जरूरत होती है। ऐसे में विभिन्न प्रकार के Threads को अलग प्रकार की Priority प्रदान करना होता है। इसलिए हर Multithreaded Programming Language में Prioritization का कोई ना कोई तरीका जरूर Develop किया गया होता है, ताकि किसी Program के विभिन्न Threads विभिन्न Priority Level पर Execute हो सकें।

जावा एक ऐसे Priority Scheduling System को Employ करता है, जिसे “Fixed Priority Scheduling” कहा जाता है। इस Scheduling में Thread का Execution अन्‍य विभिन्न Threads के “RELATIVE” Priority पर आधारित होता है। इस Priority में हर Thread को एक Relative Priority Level प्रदान किया जाता है, जिसमें विभिन्न Threads द्वारा CPU के Attention को प्राप्त किए जाने का क्रम तय होता है।

यानी ये तय होता है कि किस Thread के बाद किस Thread को CPU का Time मिलेगा। जिन Threads को High Priority प्राप्त होती है, वे Threads CPU का Attention पहले प्राप्त करते हैं जबकि जिन Threads को Low Priority प्रदान की जाती है, वे Threads CPU का Attention तब प्राप्त करते हैं, जब CPU Idle Mode में होता है।

जावा के Thread Scheduling Approach की एक सबसे महत्वपूर्ण बात ये है कि जावा Time-Slicing Approach को Use नहीं करता है। दूसरे शब्दों में कहें तो Currently जो Thread Execute हो रहा होता है, उस Thread के पास CPU का पूरा Control तब तक रहता है जब तक कि ये Thread अपना Control किसी दूसरे Thread को Transfer नहीं करता है।

इसलिए Lower Priority Threads Higher Priority Threads से CPU के Control को दिए जाने का इन्तजार करते हैं। जब Higher Priority Threads Lower Priority Threads को Control देते हैं, तब Lower Priority Threads के Codes का Execution होता है। जिन Threads का Priority Level समान होता है, वे Threads क्रम से एक दूसरे के बाद Execute होते हैं।

Java Runtime System में स्थित Garbage Collection Thread Low-Priority Thread का एक सबसे अच्छा उदाहरण है। हालांकि Garbage Collection एक बहुत ही महत्वपूर्ण काम है, लेकिन इसे CPU का Attention Urgently प्राप्त करने की कोई जरूरत नहीं होती है।

क्योंकि इस Thread का काम तब शुरू होता है जब कोई Object अपना काम पूरा कर लेता है और Destroy होता है। ये Thread Background में इन Destroy होने वाले Objects से Return होने वाली Memory व Resources को Collect करने का काम करता रहता है।

चूंकि इसका काम किसी भी Program का अन्तिम काम होता है, इसलिए इसे जावा के Runtime System में सबसे Low Priority प्रदान किया गया है। इसी तरह से User जो Input देता है, उस Input को Receive व Handle करने के लिए जो Thread काम करता है, उस Thread को Maximum Priority प्रदान किया जाता है। ताकि User के Input को तुरन्त Respond किया जा सके।

Establishing Java Thread Priority

जब एक नया Thread create होता है, तब वह Thread अपनी Priority उस Thread से Inherit करता है, जिससे यह Create हुआ होता है। Thread Class तीन Constants Define करता है तो विभिन्न Threads के Relative Priority Levels को Represent करता है। ये तीनों Constants निम्नानुसार हैं:

MIN_PRIORITY
NORM_PRIORITY
MAX_PRIORITY

जावा के Garbage Collection Thread को MIN_PRIORITY प्रदान किया गया है, जबकि वे Threads जो User के Input को Manage करते हैं, उन्हें MAX_PRIORITY प्रदान किया गया है।

सामान्‍यतया हमारे बिना किसी प्रकार की Priority Set किए हुए ही जो Threads Create होते हैं, उनकी Priority Normal ही होती है। यदि हम किसी Thread को अलग से Priority Set करना चाहें, तो इस काम के लिए हम setPriority() Method को Use करके किसी भी Thread को अलग प्रकार की Priority प्रदान कर सकते हैं।

जावा के ये Thread Priority Constants Integers होते हैं जो MIN_PRIORITY से MAX_PRIORITY तक की Range को तय करते हैं। जबकि NORM_PRIORITY इन दोनों के बीच का मान होता है। MIN_PRIORITY का मान 1 होता है जबकि MAX_PRIORITY का मान 10 होता है। इस स्थिति में NORM_PRIORITY का मान 5 होता है।

इसीलिए जब भी कोई Thread Create होता है, उसकी Priority का Level 5 होता है, क्योंकि हर नया Create होने वाला Thread एक Normal Priority वाला Tread होता है। यदि हम इस Range से बाहर की Priority Set करते हैं, तो जावा एक IllegalArgumentException नाम का Exception Throw करता है।

सामान्‍यतया यदि हम किसी Thread को किसी दूसरे Normal Priority वाले Thread से अधिक Priority देना चाहते हैं, तो हमें Normal Priority से 1 अधिक Priority Set करना होता है जबकि यदि हम किसी Thread को अन्‍य Thread की तुलना में कम Priority देना चाहते हैं, तो हमें Normal Priority से एक कम Priority Set करना होता है।

हालांकि हम किसी Thread को Minimum Priority देने के लिए 1 व Maximum Priority देने के लिए 10 का प्रयोग कर सकते हैं लेकिन फिर भी हमें ऐसा नहीं करना चाहिए। हमें इनके लिए क्रमश: Priority Level NORM_PRIORITY – 1 = 4 व Priority Level NORM_PRIORITY  + 1 = 6 का प्रयोग ही करना चाहिए। किसी Thread को Priority Set करने के लिए हम निम्नानुसार Statement का प्रयोग कर सकते हैं:

  myThread.setPriority(Thread.MAX_PRIORITY);

इसी तरह से यदि हम किसी Thread की Priority Level प्राप्त करना चाहते हैं, तो हमें getPriority() Method को निम्नानुसार Use करना होता है:

  int priority = myThread.getPriority();

किसी Thread की Priority को प्राप्त करके हम उस Thread के Priority Level Constant को Increment या Decrement करके उस Thread की Priority को अन्‍य Threads की तुलना में कम या ज्यादा पर Set कर सकते हैं। ये काम करने के लिए हम निम्नानुसार Syntax का प्रयोग कर सकते हैं:

  myThread.setPriority(myThread.getPriority() + 1 );

चूंकि हम जानते हैं कि किसी भी Thread की Normal Priority का मान 5 होता है, इसलिए यदि हम किसी Thread की Normal Priority में एक Add कर दें] तो वह Thread अन्‍य Threads की तुलना में High Priority वाला Thread बन जाता है। पिछले Statement में हमने यही काम किया है। यानी Thread को Normal Priority वाले Thread से High Priority वाले Thread में Convert किया है।

किसी Thread को Priority प्रदान करके हम ये तय करते हैं कि वह Thread CPU का Attention प्राप्त करने के लिए ज्यादा Able है या कम। उदाहरण के लिए हमें किसी Input को जितना हो सके उतना Quick तरीके से Response करना होता है। इसलिए Input से सम्बंधित Thread को हमें अन्‍य Threads की तुलना में अधिक Priority प्रदान करना जरूरी होता है।

जब कभी भी जावा में एक से ज्यादा Threads Execution के लिए CPU का Attention प्राप्त करने के लिए तैयार होते हैं, तब जावा Threads के Queue में से Highest Priority वाले Thread को चुनता है और उसे CPU पर Process होने के लिए भेज देता है। इस स्थिति में एक Lower Priority वाला Thread तब CPU का Attention प्राप्त करता है, जब निम्न में से कोई परिस्थिति होती है:

• जब Highest Priority वाले Thread के run() Method का End हो जाता है।
• जब Highest Priority वाले Thread में sleep() Method का प्रयोग किया गया होता है।
• जब Highest Priority वाले Thread में wait() Method का प्रयोग किया गया होता है।
• जब Highest Priority वाले Thread में suspend () Method का प्रयोग किया गया होता है।

Currently Running High Priority Thread के Just बाद में Execute होने वाला Thread यदि High Priority Thread नहीं है, तो Currently Thread द्वारा उस Thread को तब तक के लिए रोक दिया जाता है, जब तक Currently Running Thread पूरा नहीं हो जाता है। एक बात ध्‍यान रखें कि Highest Priority वाला Thread हमेंशा Low Priority वाले Thread को Execute होने से रोकता है।

//Program
// File Name : ThreadPriority2.java
	
class NewThread extends Thread
{
	public void run()
	{
		System.out.println("New Thread Started");
		for(int i=0; i<5; i++)
		{
			System.out.println("\t From NewThread i =" + i);
		}
		System.out.println("Exit From NewThread");
	}
}
	
class OldThread extends Thread
{
	public void run()
	{
		System.out.println("Old Thread Started");
		for(int i=0; i<5; i++)
		{
			System.out.println("\t From OldThread i =" + i);
		}
		System.out.println("Exit From OldThread");
	}
}
	
class MidThread extends Thread
{
	public void run()
	{
		System.out.println("Mid Thread Started");
		for(int i=0; i<5; i++)
		{
			System.out.println("\t From MidThread i =" + i);
		}
		System.out.println("Exit From MidThread");
	}
}
	
public class ThreadPriority2
{
	public static void main(String args[])
	{
		NewThread newThread = new NewThread();
		OldThread oldThread = new OldThread();
		MidThread midThread = new MidThread();

		newThread.setPriority(Thread.MAX_PRIORITY);
		midThread.setPriority(midThread.getPriority() + 1);
		oldThread.setPriority(Thread.MIN_PRIORITY);

		System.out.println("New Thread Started");
		newThread.start();

		System.out.println("Old Thread Started");
		oldThread.start();

		System.out.println("Mid Thread Started");
		midThread.start();

		System.out.println("End of the Main Thread");
	}
}

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

इस Program में हमने newThread Thread Object को सबसे ज्यादा Priority दी है, इसलिए Output में हम देख सकते हैं, कि ये Thread सबसे पहले Execute हो रहा है, जबकि oldThread Thread Object को हमने सबसे कम Priority दी है, इसलिए ये Thread सबसे बाद में Execute हो रहा है। यहां तक कि Main Thread का End होने के बाद ये Thread Execute होना शुरू होता है।