marq

Dr. Charles Simonyi is the Father of Modern Microsoft Excel                                           JavaScript was originally developed by Brendan Eich of Netscape under the name Mocha, later LiveScript, and finally renamed to JavaScript.                                           The word "Biology" is firstly used by Lamarck and Treviranus                                           Hippocrates (460-370 bc) is known as father of medicine.                                           Galene, 130-200 is known as father of Experimental Physology                                           Aristotle (384-322 BC) is known as Father of Zoology because he wrote the construction and behavior of different animals in his book "Historia animalium"                                           Theophrastus(370-285 BC) is known as father of Botany because he wrote about 500 different plants in his book "Historia Plantarum".                                           John Resig is known as Father of Jquery -                                          HTML is a markup language which is use to design web pages. It was invented in 1990 by Tim Berners-Lee.                                                                The Google was founded by Larry Page and Sergey Brin.                                                                Rasmus Lerdorf was the original creator of PHP. It was first released in 1995.                                                               Facebook was founded by Mark Zuckerberg                                                               Bjarne Stroustrup, creator of C++.                                                                Dennis Ritchie creator of C                                                                                                                              James Gosling, also known as the "Father of Java"                                          At 11.44%, Bihar is India's fastest growing state                                          Father of HTML -Tim Berners Lee                                          orkut was created by Orkut Büyükkökten, a Turkish software engineer                    Photoshop: It came about after Thomas Knoll, a PhD student at the University of Michigan created a program to display grayscale images on a monochrome monitor which at the time was called 'Display'.

thread


Thread States : The Life Cycle of a Thread - Java in Hindi
हमने पिछले दो उदाहरणों में ये समझा कि किस प्रकार से किसी 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 करता है। वे स्थितियां निम्नानुसार हैं:


  1. NEWBORN State
  2. RUNNABLE State
  3. RUNNING State
  4. BLOCKED State
  5. 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 करता हैः

जब Thread suspend() Method के प्रयोग द्वारा Suspend किया जाता है, तब वह Thread किसी दूसरे Thread को अपना Control Hand Over करता है। Suspended Thread को फिर से Retrieve करने के लिए resume() Method का प्रयोग किया जाता है। ये Approach तब Use किया जाता है जब हम किसी Thread को किसी कारण से कुछ समय के लिए Suspend तो करना चाहते हैं, लेकिन उसे Permanently Terminate करना नहीं चाहते हैं।
हम एक Thread को sleep() Method का प्रयोग करके भी Suspend Mode में लाते हैं। जब हम sleep() Method का प्रयोग करके किसी Thread को थोडे समय के लिए Suspend Mode में लाना चाहते हैं, तब जितने समय के लिए Thread को Suspend करना चाहते हैं, उतना समय Milliseconds के रूप में sleep() Method में Argument के रूप में Pass करते हैं। हम इस Method में Argument के रूप में जितना समय Specify करते हैं, उतना समय बीतते ही वह Thread फिर से RUNNABLE State में आ जाता है।
तीसरे तरीके में किसी 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 नहीं कर सकते हैं।

// 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 कर देता है।

No comments:

Post a Comment