जावा - बहुआयामी

जावा एक बहु-थ्रेडेड प्रोग्रामिंग भाषा है जिसका अर्थ है कि हम जावा का उपयोग करके बहु-थ्रेडेड प्रोग्राम विकसित कर सकते हैं। एक बहु-थ्रेडेड प्रोग्राम में दो या अधिक भाग होते हैं जो समवर्ती रूप से चल सकते हैं और प्रत्येक भाग एक ही समय में एक अलग कार्य को उपलब्ध संसाधनों का इष्टतम उपयोग कर सकता है, विशेष रूप से तब जब आपका कंप्यूटर कई सीपीयू रखता है।

परिभाषा के अनुसार, मल्टीटास्किंग तब होता है जब कई प्रक्रियाएं सामान्य प्रसंस्करण संसाधनों जैसे कि सीपीयू को साझा करती हैं। मल्टी-थ्रेडिंग उन अनुप्रयोगों में मल्टीटास्किंग के विचार को बढ़ाता है जहां आप एकल थ्रेड के भीतर विशिष्ट संचालन को अलग-अलग थ्रेड्स में विभाजित कर सकते हैं। प्रत्येक थ्रेड समानांतर में चल सकता है। ओएस प्रसंस्करण समय को न केवल विभिन्न अनुप्रयोगों के बीच, बल्कि एक अनुप्रयोग के भीतर प्रत्येक थ्रेड के बीच विभाजित करता है।

मल्टी-थ्रेडिंग आपको एक तरह से लिखने में सक्षम बनाता है जहां एक ही कार्यक्रम में कई गतिविधियाँ समवर्ती रूप से आगे बढ़ सकती हैं।

थ्रेड का जीवन चक्र

एक धागा अपने जीवन चक्र में विभिन्न चरणों से गुजरता है। उदाहरण के लिए, एक धागा पैदा होता है, शुरू होता है, चलाता है, और फिर मर जाता है। निम्नलिखित चित्र एक धागे के पूर्ण जीवन चक्र को दर्शाता है।

निम्नलिखित जीवन चक्र के चरण हैं -

• New- एक नया सूत्र नए राज्य में अपना जीवन चक्र शुरू करता है। यह इस स्थिति में रहता है जब तक कि कार्यक्रम थ्रेड शुरू नहीं करता है। यह भी एक के रूप में जाना जाता हैborn thread।

• Runnable- एक नवजात धागा शुरू होने के बाद, धागा चल योग्य हो जाता है। इस स्थिति में एक धागा को अपने कार्य को निष्पादित करने के लिए माना जाता है।

• Waiting- कभी-कभी, एक थ्रेड प्रतीक्षा स्थिति में संक्रमण करता है, जबकि थ्रेड किसी कार्य को करने के लिए दूसरे थ्रेड का इंतजार करता है। एक थ्रेड रन करने योग्य स्थिति में तभी वापस आता है जब कोई अन्य थ्रेड निष्पादन को जारी रखने के लिए प्रतीक्षा थ्रेड को इंगित करता है।

• Timed Waiting- समय के एक निर्दिष्ट अंतराल के लिए एक रनिंग थ्रेड समयबद्ध प्रतीक्षा स्थिति में प्रवेश कर सकता है। इस स्थिति में एक थ्रेड रननीय अवस्था में वापस आ जाता है जब उस समय का अंतराल समाप्त हो जाता है या जब उस घटना का इंतजार होता है।

• Terminated (Dead) - जब कोई व्यक्ति अपने कार्य को पूरा करता है या अन्यथा समाप्त करता है, तो एक रननीय थ्रेड समाप्त अवस्था में प्रवेश करता है।

सूत्र प्राथमिकताएँ

प्रत्येक जावा थ्रेड में एक प्राथमिकता होती है जो ऑपरेटिंग सिस्टम को उस क्रम को निर्धारित करने में मदद करती है जिसमें थ्रेड अनुसूचित हैं।

जावा थ्रेड प्राथमिकताएँ MIN_PRIORITY (1 का एक स्थिर) और MAX_PRIORITY (10 का एक निरंतर) के बीच सीमा में हैं। डिफ़ॉल्ट रूप से, प्रत्येक थ्रेड को प्राथमिकता NORM_PRIORITY (लगातार 5) दी जाती है।

उच्च प्राथमिकता वाले थ्रेड्स एक कार्यक्रम के लिए अधिक महत्वपूर्ण हैं और इन्हें कम प्राथमिकता वाले थ्रेड्स से पहले प्रोसेसर समय आवंटित किया जाना चाहिए। हालाँकि, थ्रेड प्राथमिकताएँ उस आदेश की गारंटी नहीं दे सकती हैं जिसमें थ्रेड निष्पादित होते हैं और बहुत अधिक प्लेटफ़ॉर्म पर निर्भर होते हैं।

एक Runnable इंटरफ़ेस को लागू करके एक थ्रेड बनाएँ

यदि आपकी कक्षा को एक धागे के रूप में निष्पादित करने का इरादा है तो आप इसे लागू करके प्राप्त कर सकते हैं Runnableइंटरफेस। आपको तीन बुनियादी चरणों का पालन करना होगा -

चरण 1

पहले कदम के रूप में, आपको एक रन () विधि को लागू करने की आवश्यकता है Runnableइंटरफेस। यह विधि थ्रेड के लिए एक प्रवेश बिंदु प्रदान करती है और आप इस पद्धति के अंदर अपना पूरा व्यावसायिक तर्क रखेंगे। निम्नलिखित रन () विधि का एक सरल वाक्यविन्यास है -

public void run( )

चरण 2

दूसरे चरण के रूप में, आप एक पल में करेंगे Thread निम्नलिखित कंस्ट्रक्टर का उपयोग करने वाली वस्तु -

Thread(Runnable threadObj, String threadName);

जहाँ, थ्रेडबॉज एक ऐसे वर्ग का उदाहरण है जो लागू करता हैRunnable इंटरफ़ेस और threadName नए धागे को दिया गया नाम है।

चरण 3

एक बार थ्रेड ऑब्जेक्ट बन जाने पर, आप इसे कॉल करके शुरू कर सकते हैं start()विधि, जो चलाने के लिए कॉल निष्पादित करती है () विधि। निम्नलिखित आरंभ का सरल सिंटैक्स है () विधि -

void start();

उदाहरण

यहां एक उदाहरण दिया गया है जो एक नया धागा बनाता है और इसे चलाना शुरू करता है -

class RunnableDemo implements Runnable {
   private Thread t;
   private String threadName;
   
   RunnableDemo( String name) {
      threadName = name;
      System.out.println("Creating " +  threadName );
   }
   
   public void run() {
      System.out.println("Running " +  threadName );
      try {
         for(int i = 4; i > 0; i--) {
            System.out.println("Thread: " + threadName + ", " + i);
            // Let the thread sleep for a while.
            Thread.sleep(50);
         }
      } catch (InterruptedException e) {
         System.out.println("Thread " +  threadName + " interrupted.");
      }
      System.out.println("Thread " +  threadName + " exiting.");
   }
   
   public void start () {
      System.out.println("Starting " +  threadName );
      if (t == null) {
         t = new Thread (this, threadName);
         t.start ();
      }
   }
}

public class TestThread {

   public static void main(String args[]) {
      RunnableDemo R1 = new RunnableDemo( "Thread-1");
      R1.start();
      
      RunnableDemo R2 = new RunnableDemo( "Thread-2");
      R2.start();
   }   
}

यह निम्नलिखित परिणाम का उत्पादन करेगा -

उत्पादन

Creating Thread-1
Starting Thread-1
Creating Thread-2
Starting Thread-2
Running Thread-1
Thread: Thread-1, 4
Running Thread-2
Thread: Thread-2, 4
Thread: Thread-1, 3
Thread: Thread-2, 3
Thread: Thread-1, 2
Thread: Thread-2, 2
Thread: Thread-1, 1
Thread: Thread-2, 1
Thread Thread-1 exiting.
Thread Thread-2 exiting.

थ्रेड क्लास बढ़ाकर एक थ्रेड बनाएं

एक धागा बनाने का दूसरा तरीका एक नया वर्ग बनाना है जो फैली हुई है Threadनिम्न दो सरल चरणों का उपयोग करके कक्षा। यह दृष्टिकोण थ्रेड क्लास में उपलब्ध तरीकों का उपयोग करके बनाए गए कई थ्रेड्स को संभालने में अधिक लचीलापन प्रदान करता है।

चरण 1

आपको ओवरराइड करने की आवश्यकता होगी run( )थ्रेड क्लास में उपलब्ध विधि। यह विधि थ्रेड के लिए एक प्रवेश बिंदु प्रदान करती है और आप इस पद्धति के अंदर अपना पूरा व्यावसायिक तर्क रखेंगे। निम्नलिखित रन () विधि का एक सरल वाक्यविन्यास है -

public void run( )

चरण 2

एक बार थ्रेड ऑब्जेक्ट बन जाने पर, आप इसे कॉल करके शुरू कर सकते हैं start()विधि, जो चलाने के लिए कॉल निष्पादित करती है () विधि। निम्नलिखित आरंभ का सरल सिंटैक्स है () विधि -

void start( );

उदाहरण

यहाँ थ्रेड का विस्तार करने के लिए पूर्व लिखित कार्यक्रम है -

class ThreadDemo extends Thread {
   private Thread t;
   private String threadName;
   
   ThreadDemo( String name) {
      threadName = name;
      System.out.println("Creating " +  threadName );
   }
   
   public void run() {
      System.out.println("Running " +  threadName );
      try {
         for(int i = 4; i > 0; i--) {
            System.out.println("Thread: " + threadName + ", " + i);
            // Let the thread sleep for a while.
            Thread.sleep(50);
         }
      } catch (InterruptedException e) {
         System.out.println("Thread " +  threadName + " interrupted.");
      }
      System.out.println("Thread " +  threadName + " exiting.");
   }
   
   public void start () {
      System.out.println("Starting " +  threadName );
      if (t == null) {
         t = new Thread (this, threadName);
         t.start ();
      }
   }
}

public class TestThread {

   public static void main(String args[]) {
      ThreadDemo T1 = new ThreadDemo( "Thread-1");
      T1.start();
      
      ThreadDemo T2 = new ThreadDemo( "Thread-2");
      T2.start();
   }   
}

यह निम्नलिखित परिणाम का उत्पादन करेगा -

उत्पादन

Creating Thread-1
Starting Thread-1
Creating Thread-2
Starting Thread-2
Running Thread-1
Thread: Thread-1, 4
Running Thread-2
Thread: Thread-2, 4
Thread: Thread-1, 3
Thread: Thread-2, 3
Thread: Thread-1, 2
Thread: Thread-2, 2
Thread: Thread-1, 1
Thread: Thread-2, 1
Thread Thread-1 exiting.
Thread Thread-2 exiting.

धागा विधि

थ्रेड क्लास में उपलब्ध महत्वपूर्ण विधियों की सूची निम्नलिखित है।

अनु क्रमांक।	विधि और विवरण
1	public void start() थ्रेड को निष्पादन के एक अलग पथ में शुरू करता है, फिर इस थ्रेड ऑब्जेक्ट पर रन () विधि को आमंत्रित करता है।
2	public void run() यदि इस थ्रेड ऑब्जेक्ट को एक अलग Runnable लक्ष्य का उपयोग करके त्वरित किया गया था, तो रन () विधि को उस Runnable ऑब्जेक्ट पर लागू किया जाता है।
3	public final void setName(String name) थ्रेड ऑब्जेक्ट का नाम बदलता है। नाम को पुनः प्राप्त करने के लिए एक गेटनेम () विधि भी है।
4	public final void setPriority(int priority) इस थ्रेड ऑब्जेक्ट की प्राथमिकता सेट करता है। संभावित मान 1 और 10 के बीच हैं।
5	public final void setDaemon(boolean on) सच का एक पैरामीटर इस धागे को डेमॉन थ्रेड के रूप में दर्शाता है।
6	public final void join(long millisec) वर्तमान धागा एक दूसरे धागे पर इस विधि को लागू करता है, जिससे दूसरा धागा समाप्त होने तक वर्तमान धागा अवरुद्ध हो जाता है या मिलीसेकंड की निर्दिष्ट संख्या गुजरती है।
7	public void interrupt() इस थ्रेड को बाधित करता है, जिससे किसी भी कारण से अवरुद्ध होने पर निष्पादन जारी रखना पड़ता है।
8	public final boolean isAlive() सही है अगर धागा जीवित है, जो धागा शुरू होने के बाद किसी भी समय है, लेकिन पूरा होने से पहले चलता है।

पिछले तरीके किसी विशेष थ्रेड ऑब्जेक्ट पर लागू होते हैं। थ्रेड वर्ग में निम्न विधियाँ स्थिर हैं। स्थिर तरीकों में से एक को लागू करना वर्तमान में चल रहे थ्रेड पर ऑपरेशन करता है।

अनु क्रमांक।	विधि और विवरण
1	public static void yield() वर्तमान में चल रहे धागे को उसी प्राथमिकता के किसी भी अन्य थ्रेड के लिए तैयार किया जाता है जो शेड्यूल किए जाने की प्रतीक्षा कर रहे हैं।
2	public static void sleep(long millisec) कम से कम निर्दिष्ट मिलीसेकंड के लिए ब्लॉक करने के लिए वर्तमान में चल रहे धागे का कारण बनता है।
3	public static boolean holdsLock(Object x) यदि वर्तमान थ्रेड दिए गए ऑब्जेक्ट पर लॉक रखता है, तो सही है।
4	public static Thread currentThread() वर्तमान में चल रहे धागे का संदर्भ देता है, जो कि इस विधि को लागू करने वाला धागा है।
5	public static void dumpStack() स्टैक ट्रेस को वर्तमान में चल रहे थ्रेड के लिए प्रिंट करता है, जो एक मल्टीथ्रेड एप्लिकेशन को डीबग करते समय उपयोगी होता है।

उदाहरण

निम्न थ्रेडक्लासडेमो प्रोग्राम थ्रेड क्लास के इन तरीकों में से कुछ को प्रदर्शित करता है। एक वर्ग पर विचार करेंDisplayMessage जो लागू होता है Runnable -

// File Name : DisplayMessage.java
// Create a thread to implement Runnable

public class DisplayMessage implements Runnable {
   private String message;
   
   public DisplayMessage(String message) {
      this.message = message;
   }
   
   public void run() {
      while(true) {
         System.out.println(message);
      }
   }
}

निम्नलिखित एक अन्य वर्ग है जो थ्रेड वर्ग का विस्तार करता है -

// File Name : GuessANumber.java
// Create a thread to extentd Thread

public class GuessANumber extends Thread {
   private int number;
   public GuessANumber(int number) {
      this.number = number;
   }
   
   public void run() {
      int counter = 0;
      int guess = 0;
      do {
         guess = (int) (Math.random() * 100 + 1);
         System.out.println(this.getName() + " guesses " + guess);
         counter++;
      } while(guess != number);
      System.out.println("** Correct!" + this.getName() + "in" + counter + "guesses.**");
   }
}

निम्नलिखित मुख्य कार्यक्रम है, जो उपरोक्त परिभाषित वर्गों का उपयोग करता है -

// File Name : ThreadClassDemo.java
public class ThreadClassDemo {

   public static void main(String [] args) {
      Runnable hello = new DisplayMessage("Hello");
      Thread thread1 = new Thread(hello);
      thread1.setDaemon(true);
      thread1.setName("hello");
      System.out.println("Starting hello thread...");
      thread1.start();
      
      Runnable bye = new DisplayMessage("Goodbye");
      Thread thread2 = new Thread(bye);
      thread2.setPriority(Thread.MIN_PRIORITY);
      thread2.setDaemon(true);
      System.out.println("Starting goodbye thread...");
      thread2.start();

      System.out.println("Starting thread3...");
      Thread thread3 = new GuessANumber(27);
      thread3.start();
      try {
         thread3.join();
      } catch (InterruptedException e) {
         System.out.println("Thread interrupted.");
      }
      System.out.println("Starting thread4...");
      Thread thread4 = new GuessANumber(75);
      
      thread4.start();
      System.out.println("main() is ending...");
   }
}

यह निम्नलिखित परिणाम का उत्पादन करेगा। आप इस उदाहरण को बार-बार आज़मा सकते हैं और आपको हर बार एक अलग परिणाम मिलेगा।

उत्पादन

Starting hello thread...
Starting goodbye thread...
Hello
Hello
Hello
Hello
Hello
Hello
Goodbye
Goodbye
Goodbye
Goodbye
Goodbye
.......

मेजर जावा मल्टीथ्रेडिंग कॉन्सेप्ट्स

जावा में मल्टीथ्रेडिंग प्रोग्रामिंग करते समय, आपको निम्नलिखित अवधारणाओं को बहुत काम करना होगा -

• थ्रेड सिंक्रोनाइज़ेशन क्या है?

• इंटर कम्युनिकेशन को हैंडल करना

• थ्रेड गतिरोध से निपटने

• मेजर थ्रेड ऑपरेशन