Loading...

Java in Hindi – Multithreading

  • Introduction to java multithreading in Hindi
  • Thread class implementation in java multithreading in Hindi
  • Runnable interface implementation in java multithreading in Hindi

Introduction to Java Multithreading

जब आप एक program लिखते है तो उसमे अलग अलग functions और classes के रूप में कई tasks define करते है इसके बाद जब उस program को compile किया जाता है तो compiler उसे errors के लिए check करता है और सही होने पर उस program को executable file में convert किया जाता है।

यह executable file CPU द्वारा execute की जाती है और सभी tasks sequence में एक के बाद एक perform किये जाते है। यँहा पर sequence का मतलब है की जिस order में उन tasks को define किया था उसी order में वे execute होते है और जब तक एक task पूरा नहीं हो जाता है दूसरे task का execution शुरू नहीं होता है।

इन tasks को execute करने के दौरान कई बाद CPU को wait करना पड़ जाता है। यह wait कई कारणों की वजह से हो सकता है की जैसे की user द्वारा input delay, network connection problem या किसी दूसरी process की वजह से भी CPU को wait करना पड़ सकता है।

बहरहाल यँहा पर wait इतना महत्वपूर्ण नहीं है। महत्वपूर्ण यह है की इस wait के दौरान CPU ideal condition में रहता है। यानी की CPU और कोई दूसरा task ना perform करके सिर्फ wait करता है। यह CPU के time की बर्बादी होती है।

यह wait time कोई दूसरा task perform करने में utilise किया जा सकता है। लेकिन ऐसा नहीं होता है। ऐसी situations में CPU के time का पूर्ण रूप से utilisation करने के लिए java programs में multithreading feature को implement किया जाता है।

What is Thread?

Thread को “a program in execution” phrase द्वारा define किया जाता है। यानी की जब कोई program execution में होता है या जब किसी program का execution चल रहा होता है तो वह program thread कहलाता है।

अब तक आपने सिर्फ single thread java programs create किये है, जिसमे सिर्फ एक ही thread होती है जो उस program के main() method द्वारा represent की जाती है। Multithreading की भाषा में main() method को main thread भी कहा जाता है।

Single thread programs में main thread default और एक मात्र thread होती है। इसी में आप अपने सभी tasks define करते है जो बाद में CPU द्वारा sequence में execute किये जाते है।

Concurrent Execution of Two or More Threads

Java program में एक ही single thread (main thread) को use करने के बजाय आप और दूसरी threads भी define कर सकते है। ऐसा करके आप java के multithreading feature को implement करते है।

दो या दो से अधिक threads होने पर CPU के time का पूर्ण utilization संभव हो जाता है। क्योंकि जब एक thread किसी कारणवश wait करती है तो उस समय में CPU दूसरी threads को execute करता है।

इस प्रकार program में एक से अधिक threads define करके आप CPU के time का पूर्ण utilisation करते है और इससे आपकी application भी fast हो जाती है।

Thread Life Cycle

Java में जो भी thread आप create करते है उसकी एक life cycle होती है। यह life cycle execution के दौरान उस thread द्वारा acquire की जाने वाली different states द्वारा define की जाती है। ये state changes thread के different methods के call होने पर होते है।

New -> Runnable -> Running -> Destroyed
New -> Runnable -> Running -> Waiting -> Destroyed

जब आप Thread class का object क्रिएट करते है तो वह thread अपनी सबसे पहली state new में आ जाती है। इसके बाद जब thread object पर start() method call किया जाता है तो thread runnable state में पहुँच जाती है।

इसके बाद जब run() method call होता है तो thread running state में होती है। यह state java multithreading process में सबसे अहम् होती है। इस state मे उस thread में define किये गए tasks execute होते है।

यदि thread को execution के लिए wait करना पड़े तो thread waiting state में पहुंच जाती है। जब thread का execution complete हो जाता है तो तो thread destroyed stage में पहुँच जाती है।

Thread Priority

Java में हर thread की एक priority होती है। By default threads ये priority अपनी parent thread से inherit करती है।

Priority को numerically 1 से लेकर 10 तक के numbers के द्वारा define किया जाता है। जँहा पर 1 minimum priority (MIN_PRIORITY) होती है और 10 maximum priority (MAX_PRIORITY) होती है। 5 को normal priority (NORM_PRIORITY) कहा जाता है।

Java में एक thread की priority का उपयोग thread execution को manage करने के लिए किया जाता है। सभी threads का execution उनकी priority के अनुसार ही होता है। जिस thread की priority सबसे अधिक होती है वह सबसे पहले execute की जाती है।

किसी thread की priority access करने के लिए java में getPriority() method उपयोग किया जाता है। और thread की priority set करने के लिए setPriority() method use किया जाता है।

Ways to Implement Multithreading in Java

Java में multithreading 2 तरह से implement की जा सकती है। पहले तरीके में आप Thread class को extend करते है और दूसरे तरीके में Runnable interface को implement किया जाता है।

जब आप चाहते है की आप run() method के अलावा दूसरे methods भी program में use करे तो आप Thread class को extend कर सकते है। लेकिन यदि आप सिर्फ run() override करना चाहते है तो आप Runnable interface implement कर सकते है।

Java Thread Class Implementation

Java में multithreading perform करने के लिए required methods Thread class provide करती है। Thread class में define किये गए सभी methods default implementation के साथ available है। इसके अलावा जिस method को आप चाहे अपनी class में override कर सकते है।

Thread class में 30 से भी अधिक methods available है। उनमें से कुछ महत्वपूर्ण methods यँहा बताये जा रहे है।

MethodDescription
getName()Returns name of thread.
getPriority()Returns priority of thread.
isAlive()Returns true if thread is alive.
join()Joins two threads.
run()Threads task is defined in this method.
sleep()Make a sleep for given time in milliseconds.
start()Start a thread.

Multithreading perform करने के लिए आपको इन सभी methods को override करने की आवश्यकता नहीं है। आप सिर्फ run() method override कर सकते है जो java में multithreading perform करने के लिए सबसे महत्वपूर्ण है।

Thread class में लगभग 4 constructors भी define किये गए है जो अलग अलग multithreading requirements के अनुसार execute किये जा सकते है।

run() Method

चाहे आप multithreading perform करने के लिए कोई सा भी तरीका use करे लेकिन आपको run() को override/define करना आवश्यक होता है। क्योंकि run() method में thread के द्वारा execute किये जाने वाले tasks defined होते है।

यह method start() method द्वारा call किया जाता है। जैसे ही आप Thread object के द्वारा start() method call करते है run() method start() method द्वारा call कर दिया जाता है।

Thread class को implement करते समय आप दूसरे methods भी override कर सकते है लेकिन इस run() method override करना अनिवार्य होता है। इसी प्रकार Runnable interface को implement करने पर भी run() method की definition provide करना अनिवार्य होता है।

Steps to Perform Multithreading Using Thread Class

  1. सबसे पहले आप thread class को extend करते है।
  2. इसके बाद आप अपनी class में run() method को override करते है।
  3. इसके बाद आप अपनी class (class जिससे आपने Thread class को implement किया था।) का object create करते है। Object create करते समय constructor को thread का unique नाम भी pass किया जा सकता है।
  4. इसके बाद आप उस object पर start method call करते है।
  5. इसके बाद start() method द्वारा run() method call किया जाता है और आपकी thread का execution शुरू हो जाता है।

Example1: Implement Thread Class

class JavaHindi extends thread 
{ 
    public static void main(String args[]) 
    { 
         JavaHindi jh = new JavaHindi(); 
 
         jh.start();   
    }  
 
    Public void run() 
    { 
          System.out.println(“Thread is running at www.besthinditutorials.com”); 
    } 
}

Java Runnable Interface Implementation

Java में multithreading perform करने का दूसरा तरीका Runnable interface को implement करना है। Runnable एक functional interface है। इसमें सिर्फ एक ही run() method define किया गया है जिसकी definition आप अपनी class में provide करते है।

Steps to Perform Multithreading Using Runnable Interface

Runnable interface dvara multithreading perform करने के steps आगे बताये जा रहे है।

  1. सबसे पहले आप एक class create करते है जो run() method को implement करती है और उस class create करते है।
  2. इसके बाद आप Thread class का एक object create करते है और argument के रूप में constructor को Runnable interface को implement करने वाली class और thread का नाम pass करते है।
  3. इसके बाद Thread class के object method call करते है और thread का execution शुरू हो जाता है

यँहा पर एक ध्यान देने योग्य बात यह है की इस situation में Thread class का object भी Runnable interface को implement करने वाली class को ही point करता है।

Example2: Implement Runnable Interface

class JavaHindi implements Runnable 
{ 
    JavaHindi() 
    { 
        Thread t = new Thread(this,HindiThread); 
        t.start(); 
    }    
 
    Public void run() 
    { 
          System.out.println(“Thread is running at www.besthinditutorials.com”); 
    } 
 
    public static void main(String args[]) 
    { 
         JavaHindi jh = new JavaHindi(); 
    }  
 
}

Synchronization 

Java में multithreading perform करते समय जब 2 या 2 से अधिक thread किसी एक resource (method) पर access चाहती है, तो conflict पैदा होता है। इस conflict से बचने के लिए आप एक technique यूज़ करते है। इस technique से एक समय पर एक ही thread वो resource access कर सकती है। इस technique को synchronization कहते है। 

Synchronization की technique में आप किसी method को synchronized बना देते है। इसके लिए आप उस method की definition से पहले synchronized keyword add कर देते है। जैसे –

synchronized void myMethod(){
   
}

Java multithreading में synchronization के concept को समझने के लिए आपको monitor का concept समझना होगा। हर object के साथ उसका monitor जुड़ा होता है। जब कोई thread synchronized मेथड को call करती है, तो वो थ्रेड monitor में enter हो जाती है। जैसे ही thread monitor में enter होती है उस resource पर lock लग जाता है। अब जब तक ये thread इस resource को free नहीं करेगी तब तक दूसरी कोई भी thread इस resource को access नहीं कर सकती है।

Steps to Make an Object Synchronized

किसी भी resource को synchronized बनाने के 2 तरीके होते है। एक तो जैसे की मैने आपको बताया आप method के आगे synchronized keyword लगा सकते है और उसे synchronized बना सकते है। दूसरे तरीके में आप एक synchronized block create करते है। और इस block में उस class के methods को कॉल करते है, जिनको आप synchronized बनाना चाहते है।

Example3: Create Synchronized Method

Synchronized(s1) // s1 is the object of class of which methods you are going to call 
{ 
   // call here methods that you want to make synchronized 
}

Exams और interviews के point of view से java multithreading एक बहुत ही important concept है।  

Previous: Java Packages
Next: Java File I/O