मल्टीथ्रेडिंग: थ्रेड क्लास के तरीके क्या करते हैं

नमस्ते! आज हम मल्टीथ्रेडिंग के बारे में बात करना जारी रखेंगे। आइए थ्रेड वर्ग की जाँच करें और इसके कुछ तरीके क्या करते हैं। जब हमने पहले क्लास मेथड्स का अध्ययन किया था, तो हम आमतौर पर बस यही लिखते थे: <मेथड नेम> -> <मेथड क्या करती है>। यह के तरीकों के साथ काम नहीं करेगा :) उनके पास अधिक जटिल तर्क हैं जिन्हें आप कुछ उदाहरणों के बिना समझ नहीं पाएंगे।Thread

थ्रेड.स्टार्ट () विधि

आइए स्वयं को दोहराते हुए प्रारंभ करें। जैसा कि आप शायद याद करते हैं, आप अपनी कक्षा को कक्षा का वारिस बनाकर Threadऔर run()विधि को ओवरराइड करके एक धागा बना सकते हैं। लेकिन निश्चित तौर पर यह अपने आप शुरू नहीं होगा। ऐसा करने के लिए, हम अपनी वस्तु की start()विधि कहते हैं। आइए पिछले पाठ से उदाहरण को याद करें:

public class MyFirstThread extends Thread {

   @Override
   public void run() {
       System.out.println("Thread executed: " + getName());
   }
}


public class Main {

   public static void main(String[] args) {

       for (int i = 0; i < 10; i++) {
           MyFirstThread thread = new MyFirstThread();
           thread.start();
       }
   }
}

नोट: एक थ्रेड शुरू करने के लिए, आपकोstart()के बजाय स्पेशल मेथड कोrun()! यह एक आसान त्रुटि है, खासकर जब आप पहली बार मल्टीथ्रेडिंग का अध्ययन करना शुरू करते हैं। हमारे उदाहरण में, यदि आप केrun()बजाय विधि को 10 बारstart(), तो आपको यह मिलेगा:

public class Main {

   public static void main(String[] args) {

       for (int i = 0; i < 10; i++) {
           MyFirstThread thread = new MyFirstThread();
           thread.run();
       }
   }
}

हमारे कार्यक्रम के परिणामों को देखें: थ्रेड निष्पादित: थ्रेड-0 थ्रेड निष्पादित: थ्रेड-1 थ्रेड निष्पादित: थ्रेड-2 थ्रेड निष्पादित: थ्रेड-3 थ्रेड निष्पादित: थ्रेड-4 थ्रेड निष्पादित: थ्रेड-5 थ्रेड निष्पादित: थ्रेड-6 थ्रेड निष्पादित: थ्रेड-7 थ्रेड निष्पादित: थ्रेड-8 थ्रेड निष्पादित: थ्रेड-9 आउटपुट के क्रम को देखें: सब कुछ सही क्रम में हो रहा है। अजीब, हुह? हम इसके अभ्यस्त नहीं हैं, क्योंकि हम पहले से ही जानते हैं कि जिस क्रम में थ्रेड्स शुरू और निष्पादित होते हैं, वह हमारे ऑपरेटिंग सिस्टम के अंदर एक श्रेष्ठ बुद्धि द्वारा निर्धारित किया जाता है: थ्रेड शेड्यूलर। शायद हम भाग्यशाली हो गए? बेशक, यह किस्मत की बात नहीं है। आप प्रोग्राम को कुछ और बार चलाकर इसे सत्यापित कर सकते हैं। मुद्दा यह है कि कॉल करेंrun()विधि का सीधे तौर पर मल्टीथ्रेडिंग से कोई लेना-देना नहीं है। इस स्थिति में, प्रोग्राम को मुख्य थ्रेड पर निष्पादित किया जाएगा, वही थ्रेड जो main()विधि को निष्पादित करता है। यह केवल क्रमिक रूप से कंसोल पर 10 पंक्तियों को प्रिंट करता है और बस इतना ही। 10 धागे शुरू नहीं किए गए हैं। तो भविष्य में यह याद रखो और सदा अपने को चेक करो। यदि आप run()विधि को कॉल करना चाहते हैं, तो कॉल करें start()। आगे चलते हैं।

थ्रेड.स्लीप () विधि

वर्तमान थ्रेड के निष्पादन को कुछ समय के लिए निलंबित करने के लिए, हम sleep()विधि का उपयोग करते हैं। विधि sleep()कई मिलीसेकंड को एक तर्क के रूप में लेती है, जो थ्रेड को सोने के लिए समय की मात्रा को इंगित करता है।

public class Main {

   public static void main(String[] args) throws InterruptedException {

       long start = System.currentTimeMillis();

       Thread.sleep(3000);

       System.out.println(" - How long did I sleep? \n - " + ((System.currentTimeMillis()-start)) / 1000 + " seconds");

   }
}

कंसोल आउटपुट: - मैं कितनी देर सोया? - 3 सेकंड नोट: विधि sleep()स्थैतिक है: यह वर्तमान थ्रेड को सोती है। यानी जिसे अभी अंजाम दिया जा रहा है। यहां एक और महत्वपूर्ण बिंदु है: नींद के धागे को बाधित किया जा सकता है। इस मामले में, कार्यक्रम एक फेंकता है InterruptedException। हम नीचे एक उदाहरण पर विचार करेंगे। वैसे, थ्रेड के उठने के बाद क्या होता है? क्या इसे वहीं से क्रियान्वित किया जाना जारी रहेगा जहां से इसे छोड़ा गया था? नहीं। एक थ्रेड के उठने के बाद, यानी एक तर्क के रूप में पारित समय बीत चुका है Thread.sleep(), यह चलने योग्य में परिवर्तित हो जाता हैराज्य। लेकिन, इसका मतलब यह नहीं है कि थ्रेड शेड्यूलर इसे चलाएगा। यह संभवतः किसी अन्य गैर-सोने वाले धागे को वरीयता दे सकता है और हमारे ताज़ा-जागृत धागे को थोड़ी देर बाद अपना काम जारी रखने की अनुमति दे सकता है। इसे याद रखना सुनिश्चित करें: जागने का मतलब तुरंत काम जारी रखना नहीं है!

थ्रेड.जॉइन () विधि

विधि join()वर्तमान थ्रेड के निष्पादन को तब तक के लिए निलंबित कर देती है जब तक कि कोई अन्य थ्रेड समाप्त नहीं हो जाता। अगर हमारे पास 2 धागे हैं, t1और t2, और हम लिखते हैं

t1.join()

तब तक t2शुरू नहीं होगा जब तक t1उसका काम पूरा नहीं हो जाता। join()धागे के निष्पादन आदेश की गारंटी के लिए विधि का उपयोग किया जा सकता है । आइए विचार करें कि join()निम्न उदाहरण में विधि कैसे काम करती है:

public class ThreadExample extends Thread {

   @Override
   public void run() {

       System.out.println("Thread started: " + getName());

       try {
           Thread.sleep(5000);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       System.out.println("Thread " + getName() + " is finished.");
   }
}


public class Main {

   public static void main(String[] args) throws InterruptedException {

       ThreadExample t1 = new ThreadExample();
       ThreadExample t2 = new ThreadExample();

       t1.start();


 /* The second thread (t2) will start running only after the first thread (t1)
       is finished (or an exception is thrown) */
       try {
           t1.join();
       } catch (InterruptedException e) {
           e.printStackTrace();
       }

       t2.start();

       // The main thread will continue running only after t1 and t2 have finished
       try {
           t1.join();
           t2.join();
       } catch (InterruptedException e) {
           e.printStackTrace();
       }

       System.out.println("All threads have finished. The program is finished.");

   }
}

हमने एक साधारण ThreadExampleवर्ग बनाया। इसका कार्य एक संदेश प्रदर्शित करना है कि धागा शुरू हो गया है, 5 सेकंड के लिए सो जाओ, और अंत में रिपोर्ट करें कि काम पूरा हो गया है। तुच्छ बात। मुख्य तर्क Mainवर्ग में है। टिप्पणियों को देखें: हम join()थ्रेड्स के निष्पादन क्रम को सफलतापूर्वक प्रबंधित करने के लिए विधि का उपयोग करते हैं। यदि आपको याद है कि हमने इस विषय की शुरुआत कैसे की, तो थ्रेड शेड्यूलर द्वारा निष्पादन क्रम को नियंत्रित किया जाता है। यह अपने विवेक से धागे चलाता है: हर बार एक अलग तरीके से। यहां हम यह गारंटी देने के लिए विधि का उपयोग कर रहे हैं कि t1थ्रेड को पहले शुरू किया जाएगा और पहले निष्पादित किया जाएगा, फिरt2थ्रेड, और उसके बाद ही प्रोग्राम का मेन थ्रेड जारी रहेगा। आगे बढ़ते रहना। वास्तविक कार्यक्रमों में, आपको अक्सर ऐसी परिस्थितियाँ मिलेंगी जब आपको किसी थ्रेड के निष्पादन को बाधित करने की आवश्यकता होगी। उदाहरण के लिए, हमारा थ्रेड चल रहा है, लेकिन यह किसी निश्चित घटना या स्थिति की प्रतीक्षा कर रहा है। अगर ऐसा होता है, तो धागा बंद हो जाता है। stop()अगर किसी प्रकार की विधि होती तो शायद यह समझ में आता । लेकिन यह इतना आसान नहीं है. एक बार, जावा में वास्तव में एक Thread.stop()विधि थी और एक थ्रेड को बाधित करने की अनुमति दी। लेकिन बाद में इसे जावा लाइब्रेरी से हटा दिया गया। आप इसे Oracle प्रलेखन में पा सकते हैं और देख सकते हैं कि इसे पदावनत के रूप में चिह्नित किया गया है. क्यों? क्योंकि इसने बिना कुछ और किए सिर्फ थ्रेड को रोक दिया। उदाहरण के लिए, हो सकता है कि थ्रेड डेटा के साथ काम कर रहा हो और कुछ बदल रहा हो। stop()फिर अपने काम के बीच में अचानक और बिना औपचारिकता के तरीके से काट दिया गया। उचित शटडाउन के बिना, न ही संसाधनों की रिहाई, यहां तक ​​कि त्रुटि प्रबंधन भी नहीं - इसमें से कुछ भी नहीं था। थोड़ा अतिशयोक्ति करने के लिए, stop()विधि ने अपने रास्ते में सब कुछ नष्ट कर दिया। यह कंप्यूटर को बंद करने के लिए पावर कॉर्ड को आउटलेट से खींचने जैसा था। हाँ, आप वांछित परिणाम प्राप्त कर सकते हैं। लेकिन हर कोई जानता है कि कुछ हफ़्ते के बाद कंप्यूटर आपको इस तरह से व्यवहार करने के लिए धन्यवाद नहीं देगा। इसीलिए जावा में थ्रेड्स को बाधित करने का तर्क बदल गया और अब एक विशेष interrupt()विधि का उपयोग करता है।

थ्रेड.इंटरप्ट () विधि

क्या होता है यदि interrupt()विधि को धागे पर बुलाया जाता है? 2 संभावनाएं हैं:

1. यदि वस्तु प्रतीक्षा की स्थिति में थी, उदाहरण के लिए, joinया sleepविधियों के कारण, तो प्रतीक्षा बाधित हो जाएगी और कार्यक्रम एक फेंक देगा InterruptedException।
2. यदि थ्रेड कार्यशील अवस्था में था, तो interruptedऑब्जेक्ट पर बूलियन फ़्लैग सेट किया जाएगा।

लेकिन हमें वस्तु पर इस झंडे के मूल्य की जांच करनी है और सही ढंग से काम पूरा करना है! इसलिए Threadकक्षा के पास विधि है boolean isInterrupted()। आइए घड़ी के उदाहरण पर वापस लौटते हैं जो बुनियादी पाठ्यक्रम के एक पाठ में था। सुविधा के लिए, हमने इसे थोड़ा सरल किया है:

public class Clock extends Thread {

   public static void main(String[] args) throws InterruptedException {
       Clock clock = new Clock();
       clock.start();

       Thread.sleep(10000);
       clock.interrupt();
   }

   public void run() {
       Thread current = Thread.currentThread();

       while (!current.isInterrupted())
       {
           try {
               Thread.sleep(1000);
           } catch (InterruptedException e) {
               System.out.println("The thread was interrupted");
               break;
           }
           System.out.println("Tick");
       }
   }
}

इस मामले में, घड़ी चालू हो जाती है और हर सेकंड टिक टिक करने लगती है। 10वें सेकंड में हम घड़ी की डोरी को तोड़ देते हैं। जैसा कि आप पहले से ही जानते हैं, यदि हम जिस थ्रेड को बाधित करने का प्रयास कर रहे हैं, वह प्रतीक्षा की स्थिति में है, तो परिणाम एक InterruptedException. यह एक जाँचा हुआ अपवाद है, इसलिए हम इसे आसानी से पकड़ सकते हैं और कार्यक्रम को समाप्त करने के लिए अपने तर्क को निष्पादित कर सकते हैं। और बस यही हमने किया। यहाँ हमारा परिणाम है: टिक टिक टिक टिक टिक टिक टिक टिक टिक थ्रेड बाधित था यह Threadवर्ग के सबसे महत्वपूर्ण तरीकों के लिए हमारा परिचय समाप्त करता है। आपको कामयाबी मिले!