multithreading java tutorial with examples
यह ट्यूटोरियल जावा में मल्टीथ्रेडिंग के बारे में बताता है, कंसीडर इम्प्लीमेंटेशन, थ्रेड का जीवन चक्र, थ्रेड क्लास उदाहरण, थ्रेडेबल इंटरफ़ेस का उपयोग करके थ्रेड:
कंप्यूटर की दुनिया में संगामिति एक सिस्टम की क्षमता है (यह अनुप्रयोग, कंप्यूटर, या प्रोग्रामिंग भाषा हो) समानांतर में एक कार्यक्रम या अनुप्रयोग के कई उदाहरणों को निष्पादित करने के लिए।
समवर्ती या कार्यक्रम चलाकर हम उच्च थ्रूपुट और उच्च प्रदर्शन को सुनिश्चित करते हैं क्योंकि हम ऑपरेटिंग सिस्टम हार्डवेयर आदि जैसे अप्रयुक्त संसाधनों का उपयोग कर सकते हैं। उदाहरण के लिए, यदि किसी सिस्टम में कई सीपीयू हैं, तो एप्लिकेशन इन सीपीयू का प्रभावी ढंग से उपयोग कर सकता है और थ्रूपुट को बढ़ा सकता है।
=> एक्सक्लूसिव जावा ट्रेनिंग ट्यूटोरियल सीरीज़ के लिए यहां जाएं।
आप क्या सीखेंगे:
क्या जावा में मल्टीथ्रेडिंग है
जावा में, थ्रेड्स को कंसिस्टेंसी की रीढ़ के रूप में देखा जा सकता है। एक धागा एक निष्पादन योग्य, हल्का इकाई है जो साझा संसाधनों के साथ-साथ अपने स्वयं के कॉल स्टैक तक पहुंचता है।
एक जावा एप्लिकेशन एक प्रक्रिया है और इस एप्लिकेशन के भीतर, हम संगामिति प्राप्त करने के लिए कई थ्रेड रख सकते हैं।
हम जानते हैं कि सिस्टम पर चलने वाले एप्लिकेशन के कई उदाहरण हो सकते हैं और इन्हें आमतौर पर मल्टी-डॉक एप्लिकेशन कहा जाता है। इन आवेदन उदाहरणों को प्रक्रिया कहा जाता है। इन प्रक्रियाओं में से प्रत्येक को एक निष्पादन इकाई प्रदान की जाती है जिसे थ्रेड के रूप में जाना जाता है।
ऑपरेटिंग सिस्टम और एप्लिकेशन आवश्यकताओं के आधार पर, प्रक्रिया को एक सिंगल थ्रेड या कई थ्रेड्स में से किसी एक को सौंपा जा सकता है। जब आवेदन प्रक्रिया को कई थ्रेड असाइन किए जाते हैं, तो हमें इन कई थ्रेड्स को एक साथ निष्पादित करने की आवश्यकता होती है।
' एकाधिक थ्रेड्स को एक साथ या समवर्ती रूप से निष्पादित या चलाने की इस तकनीक को मल्टीथ्रेडिंग के रूप में जाना जाता है '
मल्टीथ्रेडिंग का सीधा सा मतलब है कि हमारे पास एक ही एप्लिकेशन के अंदर एक से अधिक थ्रेड निष्पादित हैं।
जावा प्रोग्रामिंग लैंग्वेज ने मल्टीथ्रेडिंग के लिए बिल्ट-इन सपोर्ट दिया है।
उपरोक्त आरेख में मल्टीथ्रेडिंग को दर्शाया गया है। जैसा कि दिखाया गया है, कई धागे हैं जो एक अनुप्रयोग के अंदर समवर्ती चल रहे हैं।
उदाहरण के लिए, एक डेस्कटॉप एप्लिकेशन, जो संपादन, मुद्रण, आदि जैसी कार्यक्षमता प्रदान करता है, एक मल्टीथ्रेडेड एप्लिकेशन है। इस एप्लिकेशन में, जैसा कि मुद्रण एक पृष्ठभूमि प्रक्रिया है, हम इन दस्तावेज़ों को दो अलग-अलग थ्रेड्स में असाइन करके संपादन दस्तावेज़ और मुद्रण दस्तावेज़ समवर्ती प्रदर्शन कर सकते हैं।
मल्टीथ्रेडेड एप्लिकेशन में थ्रेड्स समवर्ती तरीके से एक दूसरे के समानांतर चलते हैं। इस प्रकार मल्टीथ्रेडिंग भी जावा में कॉन्सेप्ट का एक हिस्सा है। ध्यान दें कि हालांकि कई सूत्र हैं, वे मेमोरी क्षेत्र को साझा करते हैं जिससे मेमोरी पर बचत होती है। इसके अलावा, थ्रेड आसानी से कुछ ही समय में संदर्भ बदल सकते हैं।
मल्टीथ्रेडिंग मुख्य रूप से उपयोगी है क्योंकि यह एक अनुप्रयोग के दो या अधिक भागों का समवर्ती निष्पादन प्रदान करता है। यह एप्लिकेशन को CPU समय का अधिकतम और निष्क्रिय समय का उपयोग न्यूनतम करने के लिए रखा गया है।
निम्नलिखित कुछ शर्तें हैं जिन्हें हमें बहुपरत पर्यावरण के संबंध में जानना चाहिए क्योंकि वे अक्सर उपयोग किए जाते हैं।
बहु कार्यण: मल्टीटास्किंग में, एक ही समय में एक से अधिक कार्य निष्पादित किए जाते हैं।
मल्टीथ्रेडिंग: मल्टीथ्रेडिंग, जैसा कि पहले ही उल्लेख किया गया है एक साथ कई थ्रेड्स निष्पादित करने की एक प्रक्रिया है।
आप एक उत्पाद परीक्षक कैसे बनते हैं
मल्टीप्रोसेसिंग: मल्टीप्रोसेसिंग में, एक से अधिक प्रक्रियाओं को एक साथ निष्पादित किया जाता है। मल्टीटास्किंग के समान, लेकिन यहां एक से अधिक सीपीयू शामिल हैं।
समानांतर प्रसंस्करण: समानांतर प्रसंस्करण एक ऐसी तकनीक है जिसमें कंप्यूटर सिस्टम में एक साथ कई सीपीयू काम करते हैं।
मल्टीथ्रेडिंग पर चर्चा करने के बाद, यह सवाल उठता है कि आखिर हमें मल्टीथ्रेडिंग की आवश्यकता क्यों है?
मल्टीथ्रेडिंग के लाभ
मल्टीथ्रेडिंग के विभिन्न लाभ हैं जो कुशल प्रोग्रामिंग में सहायता करते हैं।
नीचे दिए गए बिंदु इसे स्पष्ट करेंगे।
# 1) सिंगल सीपीयू सिस्टम का कुशल उपयोग
जब सिस्टम में केवल एक सीपीयू होता है, एक एकल थ्रेड के साथ तब सीपीयू समय बर्बाद होता है। जब धागा IO जैसे अन्य संसाधनों का उपयोग करने में व्यस्त होता है, तो सीपीयू निष्क्रिय हो जाता है। हम इस पर सुधार कर सकते हैं और मल्टीथ्रेडेड एप्लिकेशन होने से सीपीयू का बेहतर उपयोग कर सकते हैं।
मल्टीथ्रेडिंग का उपयोग करके, यदि एक धागा सीपीयू के साथ किया जाता है, तो दूसरा धागा इसका उपयोग कर सकता है। कई थ्रेड्स के साथ, सीपीयू निष्क्रिय समय बहुत कम हो जाएगा।
# 2) मल्टीपल सीपीयू सिस्टम का कुशल उपयोग
सिंगल सीपीयू की तरह, कई सीपीयू वाले सिस्टम के साथ भी, मल्टीथ्रेडेड एप्लिकेशन कई सीपीयू को कुशलतापूर्वक उपयोग करने में सक्षम हैं।
# 3) जवाबदेही और निष्पक्षता के संबंध में बेहतर उपयोगकर्ता अनुभव
मल्टीथ्रेड एप्लिकेशन के साथ सिस्टम की जवाबदेही में सुधार होता है। हम अनुभव नहीं करते ‘जीयूआई फांसी’ जब हमारे पास एप्लिकेशन में कई कार्य पूरे होते हैं और उपयोगकर्ताओं को उनके अनुरोधों के लिए प्रतिक्रिया प्राप्त करने के लिए लंबे समय तक प्रतीक्षा करने की आवश्यकता नहीं होती है।
इसी तरह, उपयोगकर्ता मल्टीथ्रेडेड सिस्टम में ठीक से सेवाएं हैं।
जावा में कंसीलर को कैसे कार्यान्वित करें
पहला वर्ग जिसके उपयोग से हम जावा में संगामिति को लागू कर सकते हैं java.lang.Thread कक्षा। यह थ्रेड क्लास जावा में कंसिस्टेंसी का आधार बनाता है।
हमारे पास भी है java.lang.Runnable एक जावा वर्ग द्वारा लागू किया जा सकने वाला इंटरफ़ेस थ्रेड बिहेवियर को अमूर्त करने के लिए। उन्नत अनुप्रयोग विकास के लिए, हम इसका उपयोग कर सकते हैं java.util.concurrent जावा 1.5 के बाद से उपलब्ध पैकेज।
आगे बढ़ते हुए हम जावा में संगामिति पर विस्तार से चर्चा करेंगे। आइए इस ट्यूटोरियल में जावा में थ्रेड्स की अवधारणा पर चर्चा करें और समझें। मल्टीथ्रेडिंग पर हमारे बाद के ट्यूटोरियल्स में, हम विभिन्न मल्टीथ्रेडिंग और कॉन्सेप्ट अवधारणाओं का पता लगाएंगे।
जावा में एक धागा क्या है
एक एकल धागे को प्रसंस्करण की सबसे छोटी और हल्की इकाई के रूप में परिभाषित किया जा सकता है। जावा में, थ्रेड्स का उपयोग 'थ्रेड' क्लास के कार्यक्रमों में किया जाता है।
जावा धागे दो प्रकार के होते हैं:
# 1) उपयोगकर्ता धागा: उपयोगकर्ता थ्रेड तब बनाया जाता है जब एप्लिकेशन पहले शुरू होता है। फिर हम कई उपयोगकर्ता और डेमन थ्रेड बना सकते हैं।
# 2) डेमॉन धागा: डेमन थ्रेड्स मुख्य रूप से पृष्ठभूमि में उपयोग किए जाते हैं और एप्लिकेशन को साफ करने जैसे कार्यों के लिए उपयोग किए जाते हैं, आदि।
थ्रेड्स आवेदन की रखरखाव लागत को कम करते हैं। यह एप्लिकेशन ओवरहेड को भी कम करता है।
एक एकल थ्रेड उदाहरण नीचे दिखाया गया है:
public class Main{ public static void main (String () args){ System.out.println('This is a thread'); } } उपरोक्त कार्यक्रम 'यह एक धागा है' प्रदर्शित करेगा जब अनुप्रयोग शुरू होता है एक उपयोगकर्ता धागा बनाया जाता है। उपरोक्त कार्यक्रम में, मुख्य कार्य अनुप्रयोग का प्रारंभिक बिंदु है और यह एक उपयोगकर्ता थ्रेड बनाता है।
एक धागे का जीवन चक्र
निम्नलिखित चित्र जावा में एक धागे के जीवन चक्र को दर्शाता है।
जैसा कि ऊपर चित्र में दिखाया गया है, जावा में एक धागे में निम्नलिखित अवस्थाएँ हैं:
YouTube से ऑडियो डाउनलोड करने का सबसे अच्छा तरीका
# 1) नया: प्रारंभ में, केवल थ्रेड क्लास से बनाए गए थ्रेड में एक 'नया' राज्य होता है। इसे शुरू किया जाना बाकी है। यह धागा भी कहा जाता है ‘पैदाइशी धागा’ ।
# 2) चलाने योग्य: इस स्थिति में, थ्रेड का उदाहरण विधि का उपयोग करके किया जाता है 'शुरू' ।
# 3) रनिंग: थ्रेड आवृत्ति की प्रारंभ विधि लागू होती है और थ्रेड निष्पादन शुरू होता है। यह रनिंग स्टेट है। ज्यादातर शेड्यूलर शेड्यूल करते हैं और थ्रेड का प्रबंधन करते हैं।
# 4) अवरुद्ध: एक आवेदन में कई सूत्र हैं। इन थ्रेड्स को दूसरे के लिए इंतजार करना होगा क्योंकि उनके निष्पादन को सिंक्रनाइज़ करना होगा।
# 5) समाप्त: एक बार थ्रेड की निष्पादन प्रक्रिया समाप्त हो जाने के बाद, थ्रेड को समाप्त कर दिया जाता है या इसके निष्पादन को रोक दिया जाता है।
तो एक थ्रेड पहले बनाया जाता है, फिर शेड्यूल किया जाता है और बाद में शेड्यूलर थ्रेड को निष्पादित करता है। जबकि चल रहे धागे को किसी अन्य गतिविधि के लिए अवरुद्ध या निलंबित किया जा सकता है। फिर इसे फिर से शुरू किया जाता है और प्रसंस्करण पूरा होने के दौरान, थ्रेड निष्पादित किया जाता है।
सूत्र प्राथमिकताएँ
एक थ्रेड प्राथमिकता यह तय करती है कि एक आवेदन में अन्य थ्रेड्स के संबंध में एक थ्रेड को कैसे माना जाए। एक थ्रेड प्राथमिकता एक पूर्णांक संख्या है।
थ्रेड प्राथमिकता के बारे में याद रखने के लिए नीचे सूचीबद्ध कुछ बिंदु हैं:
- थ्रेड प्राथमिकताएँ पूर्णांक संख्याएँ हैं।
- थ्रेड प्राथमिकता का उपयोग करते हुए, हम तय कर सकते हैं कि कब हमें एक थ्रेड से दूसरे राज्य में स्विच करना चाहिए। यह संदर्भ स्विचिंग प्रक्रिया है जिसमें हम थ्रेड्स के संदर्भ स्विच करते हैं।
- कभी भी एक धागा सीपीयू पर स्वेच्छा से अपना नियंत्रण जारी कर सकता है। फिर सर्वोच्च प्राथमिकता वाला धागा ले सकता है।
- इसी तरह, एक उच्च प्राथमिकता वाला धागा किसी भी अन्य धागे को कम प्राथमिकता के साथ हटा सकता है।
- थ्रेड क्लास एक सेटपैरिटी () विधि प्रदान करता है जिसका उपयोग थ्रेड के लिए प्राथमिकता निर्धारित करने के लिए किया जाता है।
- हम पूर्णांक के स्थान पर स्थिरांक MIN_PRIORITY, MAX_PRIORITY या NORM_PRIORITY का उपयोग भी कर सकते हैं।
एक धागा बनाएँ
हम निम्नलिखित तरीकों में से किसी का उपयोग करके एक धागा बना सकते हैं:
- जावा the थ्रेड ’वर्ग का विस्तार।
- Plement रननेबल ’को लागू करना।
जावा The थ्रेड ’क्लास का विस्तार
क्लास 'थ्रेड' में वे निर्माता और विधियाँ शामिल हैं जो हमें थ्रेड ऑब्जेक्ट पर ऑपरेशन बनाने और प्रदर्शन करने की अनुमति देती हैं। आंतरिक रूप से थ्रेड क्लास रनने योग्य इंटरफ़ेस को लागू करता है और ऑब्जेक्ट क्लास को भी विस्तारित करता है।
निम्न तालिका थ्रेड () वर्ग के विभिन्न कंस्ट्रक्टरों और विधियों का सारांश देती है।
| बिल्डर / | प्रोटोटाइप | विवरण |
|---|---|---|
| नींद | सार्वजनिक शून्य नींद (लंबी मिलीसेकंड) | वर्तमान थ्रेड का निष्पादन निर्दिष्ट मिलीसेकंड के लिए रोक दिया जाता है। |
| धागा () निर्माता | धागा () | एक थ्रेड ऑब्जेक्ट बनाने के लिए डिफ़ॉल्ट कंस्ट्रक्टर। |
| धागा (स्ट्रिंग नाम) | निर्दिष्ट नाम के साथ एक थ्रेड ऑब्जेक्ट बनाने के लिए कंस्ट्रक्टर। | |
| थ्रेड (रन करने योग्य आर) | निर्दिष्ट Runnable इंटरफ़ेस ऑब्जेक्ट के साथ थ्रेड आवृत्ति बनाएँ। | |
| थ्रेड (रन करने योग्य आर, स्ट्रिंग नाम) | निर्दिष्ट Runnable इंटरफ़ेस ऑब्जेक्ट और दिए गए नाम के साथ थ्रेड आवृत्ति बनाएँ | |
| Daud | सार्वजनिक शून्य रन () | रन विधि एक थ्रेड के लिए क्रिया करती है। धागा आमंत्रित करता है। |
| शुरू | सार्वजनिक शून्य प्रारंभ () | धागे के निष्पादन को शुरू करने के लिए उपयोग किया जाता है। आंतरिक रूप से इस धागे पर जेवीएम कॉल रन () विधि है। |
| में शामिल होने के | सार्वजनिक शून्य में शामिल हों () | थ्रेड के मरने की प्रतीक्षा करें |
| सार्वजनिक शून्य में शामिल (लंबे मिलीसेकंड) | धागा मरने के लिए निर्दिष्ट मिलीसेकंड के लिए प्रतीक्षा करें। | |
| वैराग्य | सार्वजनिक इंट गेटपैरिटी () | थ्रेड प्राथमिकता वापस करें |
| प्राथमिकता दर्ज करें | सार्वजनिक int सेटपैरिटी (int प्राथमिकता) | थ्रेड प्राथमिकता को निर्दिष्ट प्राथमिकता में बदलें |
| मिलता है | सार्वजनिक स्ट्रिंग getName () | धागे का नाम वापस करें। |
| नाम भरें | सार्वजनिक शून्य सेटनाम (स्ट्रिंग नाम) | थ्रेड का नाम निर्दिष्ट स्ट्रिंग पर सेट करें |
| वर्तमान | सार्वजनिक धागा चालू () | वर्तमान में सक्रिय थ्रेड का संदर्भ देता है |
| GetId | सार्वजनिक int getId () | वापसी धागा आईडी |
| getState () | सार्वजनिक थ्रेड। गेट गेट () | थ्रेड की वर्तमान स्थिति देता है |
| जिंदा है | सार्वजनिक बूलियनएलाइव () है | जांचें कि क्या धागा जीवित है और यदि हां तो सही है। |
| प्राप्ति | सार्वजनिक शून्य उपज () | अस्थायी रूप से वर्तमान थ्रेड को रोक देता है और अन्य थ्रेड्स को निष्पादित करने की अनुमति देता है। |
| है | सार्वजनिक बूलियन डेमॉन () | जांचें कि क्या धागा एक डेमन धागा है; सही होने पर हाँ। |
| सेटडैमन | सार्वजनिक शून्य सेटडैमन (बूलियन बी) | धागे को डेमन थ्रेड के रूप में सेट करें यदि b = true; उपयोगकर्ता थ्रेड के रूप में सेट करें। |
| बाधा | सार्वजनिक शून्य व्यवधान () | वर्तमान धागे को बाधित करें। |
| बाधित है | सार्वजनिक बूलियन बाधित है () | जांचें कि क्या थ्रेड बाधित है। |
| बाधित | सार्वजनिक स्थैतिक बूलियन बाधित () | जांचें कि क्या वर्तमान थ्रेड बाधित हो गया है। |
| डंपस्टैक | स्थैतिक शून्य डंपस्टैक () | मानक त्रुटि स्ट्रीम में वर्तमान थ्रेड का एक स्टैक ट्रेस मुद्रित करता है। |
| निलंबित | सार्वजनिक शून्य निलंबित () | सभी थ्रेड्स को निलंबित करता है। (** नवीनतम जावा संस्करणों में विधि को हटा दिया गया है) |
| बायोडाटा | सार्वजनिक शून्य फिर से शुरू () | निलंबित धागा फिर से शुरू करें। (** नवीनतम जावा संस्करणों में विधि को हटा दिया गया है) |
| रुकें | सार्वजनिक शून्य रोक () | धागा रोकता है। (** नवीनतम जावा संस्करणों में विधि को हटा दिया गया है) |
हम मल्टीथ्रेडिंग पर अपने अगले ट्यूटोरियल में इन थ्रेड विधियों पर विस्तार से बताएंगे।
एक धागा शुरू करना
विधि प्रारंभ () जो थ्रेड को प्रारंभ करने के लिए उपयोग की जाती है वह निम्न चरणों को पूरा करती है:
- एक नया CallStack के साथ एक नया थ्रेड उदाहरण प्रारंभ करता है।
- थ्रेड स्टेट को नए से रननीय में बदला जाता है।
- जब यह थ्रेड की बारी है, तो यह रन () विधि को निष्पादित करता है।
'Runnable' इंटरफ़ेस लागू करना
रननेबल इंटरफ़ेस का उपयोग करके एक थ्रेड इंस्टेंस भी बनाया जा सकता है। एक थ्रेड आवृत्ति बनाने के लिए, वह वर्ग जिसकी ऑब्जेक्ट्स को थ्रेड द्वारा निष्पादित किया जाना चाहिए, रननेबल इंटरफ़ेस को लागू करना चाहिए।
Runnable इंटरफ़ेस में केवल एक विधि है:
public void run () => this method is used to execute the thread. थ्रेड क्लास उदाहरण
अब थ्रेड क्लास का उपयोग करके जावा में थ्रेड प्रदर्शित करते हैं।
//class inherited from 'Thread' class ThreadClassDemo extends Thread { private int number; //class constructor public ThreadClassDemo(int number) { this.number = number; } //run method => execution code for thread public void run() { int counter = 0; int numInt = 0; //prints the number till specified number is reached, starting from 10 do { numInt = (int) (counter + 10); System.out.println(this.getName() + ' prints ' + numInt); counter++; } while(numInt != number); System.out.println('** Correct! ' + this.getName() + 'printed ' + counter + ' times.**'); } } public class Main { public static void main(String () args) { System.out.println('Starting thread_1...'); //create a thread class instance Thread thread_1 = new ThreadClassDemo(15); //start the thread thread_1 thread_1.start(); try { //wait for thread_1 to die thread_1.join(); } catch (InterruptedException e) { System.out.println('Thread interrupted.'); } System.out.println('Starting thread_2...'); Thread thread_2 = new ThreadClassDemo(20); //start thread_2 thread_2.start(); System.out.println('main() is ending...'); } } उत्पादन
जावा थ्रेड रननीयेबल इंटरफेस का उपयोग करना
थ्रेड उदाहरण बनाने के लिए निम्न उदाहरण रननेबल इंटरफ़ेस के उपयोग को दर्शाता है।
//class implements Runnable interface class RunnableDemo implements Runnable { private String message; //class constructor public RunnableDemo(String message) { this.message = message; } //run method public void run() { while(true) { System.out.println(message); } } } public class Main { public static void main(String () args) { //create first thread instance hello Runnable hello = new RunnableDemo('Hello, Greetings!!!'); Thread thread1 = new Thread(hello); thread1.setDaemon(true); //set this thread as daemon thread1.setName('hello'); System.out.println('Starting First thread...'); //start the thread thread1.start(); //create second thread instance bye Runnable bye = new RunnableDemo('Bye for now!!'); Thread thread2 = new Thread(bye); thread2.setPriority(Thread.MIN_PRIORITY); //set priority to min thread2.setDaemon(true); //set as daemon thread System.out.println('Starting goodbye thread...'); //start the thread thread2.start(); System.out.println('main() is ending...'); } }उत्पादन
जावा में एक थ्रेड को कैसे रोकें
हमने ऊपर थ्रेड उदाहरणों को देखा है। इन उदाहरणों से, हम जानते हैं कि जब रन पद्धति निष्पादन को पूरा करती है, तो थ्रेड रुक जाता है या कुछ अपवादों के कारण भी रुक जाता है।
जावा के पहले के संस्करणों में थ्रेड क्लास में स्टॉप () पद्धति थी जिसका उपयोग सीधे थ्रेड को रोकने के लिए किया जा सकता था। लेकिन इसे अब सुरक्षा कारणों से हटा दिया गया है। इस प्रकार हमें निष्पादित होने वाले धागे को रोकने के लिए अन्य तरीकों को नियोजित करने की आवश्यकता है।
धागे को रोकने के लिए हम दो तरीके अपना सकते हैं।
- एक अस्थिर बूलियन चर का उपयोग करना
- इंटरप्ट का उपयोग करना।
इस खंड में, हम एक सूत्र को रोकने के इन दोनों तरीकों पर चर्चा करेंगे।
एक अस्थिर बूलियन चर का उपयोग करना
इस विधि में, हम बूलियन वैरिएबल फ़्लैग को बनाए रखते हैं, थ्रेड को रोकने के लिए। जब तक बूलियन वेरिएबल सही पर सेट नहीं होता तब तक धागा चलता रहता है। जिस क्षण यह असत्य हो जाता है, धागा बंद हो जाता है।
इस विधि की खासियत यह है कि हम बूलियन वैरिएबल को 'घोषित' करते हैं। परिवर्तनशील 'इसलिए कि यह हमेशा मुख्य मेमोरी से पढ़ा जाता है और प्रोग्राम इसे सीपीयू कैश में कैश नहीं कर सकता है। इस तरह, सेट और पढ़ने के मूल्यों में कोई अंतर नहीं होगा।
एक अस्थिर बूलियन चर का उपयोग करके एक धागा को रोकने का कार्यान्वयन नीचे दिखाया गया है।
class StopThread extends Thread { private volatile boolean stop_flag = true; //initially set to true public void stopRunning() { stop_flag = false; //set stop_flag to false } @Override public void run() { while (stop_flag) { //keep checking value of stop_flag System.out.println('Thread is running...'); } System.out.println('Thread stopped!!!'); } } public class Main { public static void main(String() args) { //create a thread instance StopThread stop_thread = new StopThread(); //start the thread stop_thread.start(); try { Thread.sleep(10); } catch (InterruptedException e) { e.printStackTrace(); } //call stopRunning() method to stop the thread stop_thread.stopRunning(); } } उत्पादन
ध्यान दें: यहां हमने केवल आउटपुट का एक भाग दिखाया है। रोकने से पहले धागा कई मिनट तक चल सकता है। ताकि हम अलग-अलग सिस्टम पर अलग-अलग आउटपुट प्राप्त कर सकें।
इंटरप्ट का उपयोग करना
यहां थ्रेड () विधि का उपयोग करके थ्रेड को बंद कर दिया गया है क्योंकि हमने थ्रेड क्लास के तरीकों में पहले ही ऊपर चर्चा की है। बाधित () विधि थ्रेड की स्थिति को बाधित के रूप में सेट करती है। यह स्थिति रन () विधि के लूप को पारित की जाती है। हम बाधित () पद्धति का उपयोग करके बाधित स्थिति प्राप्त कर सकते हैं।
निम्न प्रोग्राम थ्रेड को रोकने के लिए इंटरप्ट () विधि के उपयोग को प्रदर्शित करता है।
class StopThread extends Thread { @Override public void run() { while (!Thread.interrupted()) { //check for interrupted status System.out.println('Thread is running...'); } System.out.println('Thread stopped!!!'); } } public class Main { public static void main(String() args) { //create a thread instance StopThread stop_thread = new StopThread(); //start the thread stop_thread.start(); try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } //interrupt the thread stop_thread.interrupt(); } } उत्पादन
बार बार पूछे जाने वाले प्रश्न
क्यू # 1) हम जावा में मल्टीथ्रेडिंग का उपयोग क्यों करते हैं?
उत्तर: मल्टीथ्रेडिंग एक आवेदन में दो या अधिक धागे के समवर्ती या एक साथ निष्पादन की अनुमति देता है। समवर्ती निष्पादन थ्रूपुट को अधिकतम करता है और सीपीयू का अधिकतम उपयोग करता है।
Q # 2) मल्टीथ्रेडिंग क्या है? इसके प्रकार क्या हैं?
उत्तर: मल्टीथ्रेडिंग का अर्थ है एक से अधिक थ्रेड को निष्पादित करना। यह निष्पादन समवर्ती या समानांतर हो सकता है। इस प्रकार, मल्टीथ्रेडिंग के दो प्रकार होते हैं अर्थात् समवर्ती या समानांतर।
Q # 3) मल्टीप्रोसेसिंग बनाम मल्टीप्रोसेसिंग क्या है?
उत्तर: मल्टीथ्रेडिंग में, समान या अलग-अलग प्रक्रियाओं के लिए कई थ्रेड होते हैं और ये थ्रेड्स किसी सिस्टम की कंप्यूटिंग गति को बढ़ाने के लिए समवर्ती रूप से निष्पादित होते हैं। मल्टीप्रोसेसिंग में, एक सिस्टम में दो से अधिक सीपीयू होते हैं और कई प्रक्रियाएं एक साथ निष्पादित होती हैं।
Q # 4) जावा में मल्टीथ्रेडिंग के क्या फायदे हैं?
उत्तर: मल्टीथ्रेडिंग का उपयोग करके हम थ्रेड्स का उपयोग करते हुए एक साथ विभिन्न एप्लिकेशनों के विभिन्न हिस्सों को निष्पादित कर सकते हैं। मल्टीथ्रेडिंग से सिस्टम थ्रूपुट बढ़ता है। मल्टीथ्रेडिंग भी सीपीयू उपयोग को अधिकतम करता है क्योंकि विभिन्न धागे लगातार सीपीयू का उपयोग करते हैं।
Q # 5) क्या गेमिंग के लिए मल्टीथ्रेडिंग अच्छा है?
उत्तर: हां, खासकर आधुनिक खेलों के लिए।
निष्कर्ष
यह सब मल्टीथ्रेडिंग की शुरुआत के बारे में है। हमने इस ट्यूटोरियल में जावा में कंसीलर और मल्टी-थ्रेडिंग पर चर्चा की है। हमने थ्रेड क्लास के साथ-साथ रननेबल इंटरफ़ेस के साथ एक थ्रेड के निर्माण पर चर्चा की और उपयुक्त उदाहरण प्रदान किए हैं।
हमने एक भी सूत्र और इसके निर्माण की अवधारणाओं को विस्तार से सीखा है। इस ट्यूटोरियल में एक थ्रेड के जीवन चक्र, एक थ्रेड को रोकना, थ्रेड के प्रकार आदि को शामिल किया गया है।
हमने जावा में लंबाई और समसामयिकता पर चर्चा की। इस ट्यूटोरियल के अंत में, पाठक को आसानी से कॉनसेप्ट और मल्टीथ्रेडिंग की अवधारणाओं को समझने और जावा में थ्रेड को समझने में सक्षम होना चाहिए।
=> यहाँ सरल जावा प्रशिक्षण श्रृंखला देखें।
अनुशंसित पाठ
- उदाहरणों के साथ C ++ में गुणा करना
- जावा थ्रेड्स विथ मेथड्स एंड लाइफ साइकल
- थ्रेड स्लीप () - थ्रेड स्लीप () विधि जावा में उदाहरण के साथ
- जावा ट्यूटोरियल फॉर बिगिनर्स: 100+ हैंड्स-ऑन जावा वीडियो ट्यूटोरियल
- उदाहरणों के साथ जावा परावर्तन ट्यूटोरियल
- जावा स्ट्रिंग में () विधि ट्यूटोरियल विथ उदाहरण हैं
- जावा में दांतेदार सरणी - उदाहरणों के साथ ट्यूटोरियल
- उदाहरण के साथ जावा स्कैनर क्लास ट्यूटोरियल