उदाहरणों के साथ जावा ट्यूटोरियल में मल्टीथ्रेडिंग

किसी भी एप्लिकेशन में कई प्रक्रियाएं (उदाहरण) हो सकती हैं। इस प्रक्रिया में से प्रत्येक को एक धागे या कई धागे के रूप में सौंपा जा सकता है। हम इस ट्यूटोरियल में देखेंगे कि एक ही समय में कई कार्य कैसे करें और थ्रेड्स के बीच थ्रेड्स और सिंक्रनाइज़ेशन के बारे में अधिक जानें।

इस ट्यूटोरियल में, हम सीखेंगे:

• सिंगल धागा क्या है
• जावा में मल्टीथ्रेडिंग क्या है?
• जावा में थ्रेड जीवन चक्र
• जावा थ्रेड सिंक्रोनाइज़ेशन
• जावा मल्टीथ्रेडिंग उदाहरण

सिंगल थ्रेड क्या है?

एक एकल धागा मूल रूप से एक हल्का और प्रसंस्करण की सबसे छोटी इकाई है। जावा "थ्रेड क्लास" का उपयोग करके थ्रेड्स का उपयोग करता है।

दो प्रकार के धागे हैं - उपयोगकर्ता धागा और डेमन थ्रेड (डेमन थ्रेड्स का उपयोग तब किया जाता है जब हम एप्लिकेशन को साफ करना चाहते हैं और पृष्ठभूमि में उपयोग किया जाता है)।

जब कोई एप्लिकेशन पहली बार शुरू होता है, तो उपयोगकर्ता थ्रेड बनाया जाता है। पोस्ट करें कि, हम कई उपयोगकर्ता थ्रेड और डेमन थ्रेड बना सकते हैं।

एकल धागा उदाहरण:

पैकेज डिमोटेस्ट;सार्वजनिक वर्ग गुरुग्रंथ{{सार्वजनिक स्थैतिक शून्य main (String [] args) {System.out.println ("सिंगल थ्रेड");}}

एकल धागे के लाभ:

• अनुप्रयोग में ओवरहेड को कम करता है क्योंकि सिस्टम में एकल थ्रेड निष्पादित होता है
• इसके अलावा, यह आवेदन की रखरखाव लागत को कम करता है।

जावा में मल्टीथ्रेडिंग क्या है?

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

बहु सूत्र का उदाहरण:

पैकेज डिमोटेस्ट;सार्वजनिक वर्ग GuruThread1 लागू किया जा सकता है{{सार्वजनिक स्थैतिक शून्य main (String [] args) {थ्रेड गुरुट्रेड 1 = नया थ्रेड ("गुरु 1");थ्रेड गुरुट्रेड 2 = नया थ्रेड ("गुरु 2");guruThread1.start ();guruThread2.start ();System.out.println ("थ्रेड नाम निम्नलिखित हैं:");System.out.println (guruThread1.getName ());System.out.println (guruThread2.getName ());}@ ऑवरराइडसार्वजनिक शून्य रन () {}}

मल्टीथ्रेड के लाभ:

• थ्रेड स्वतंत्र होने के कारण उपयोगकर्ता अवरोधित नहीं हैं, और हम कई बार कई कार्य कर सकते हैं
• जैसे कि धागे स्वतंत्र होते हैं, यदि एक धागा अपवाद को पूरा करता है तो अन्य धागे प्रभावित नहीं होंगे।

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

एक धागे का जीवनचक्र:

धागे के जीवन चक्र के विभिन्न चरण हैं जैसा कि ऊपर चित्र में दिखाया गया है:

1. नवीन व
2. चलाने योग्य
3. दौड़ना
4. इंतज़ार कर रही
5. मरे हुए

1. नई: इस चरण में, "थ्रेड क्लास" का उपयोग करके थ्रेड बनाया जाता है। यह इस अवस्था में रहता है जब तक प्रोग्राम थ्रेड शुरू नहीं करता है। इसे पैदाइशी धागे के रूप में भी जाना जाता है।
2. रन करने योग्य: इस पृष्ठ में, थ्रेड का उदाहरण एक प्रारंभ विधि के साथ दिया गया है। निष्पादन को समाप्त करने के लिए थ्रेड कंट्रोलर को शेड्यूलर को दिया जाता है। यह शेड्यूलर पर निर्भर करता है, कि थ्रेड को चलाना है या नहीं।
3. रनिंग: जब थ्रेड निष्पादित करना शुरू कर देता है, तो राज्य को "रनिंग" स्थिति में बदल दिया जाता है। शेड्यूलर थ्रेड पूल से एक थ्रेड का चयन करता है, और यह एप्लिकेशन में निष्पादित करना शुरू कर देता है।
4. प्रतीक्षा: यह वह अवस्था है जब किसी सूत्र को प्रतीक्षा करनी होती है। चूंकि अनुप्रयोग में कई थ्रेड चल रहे हैं, थ्रेड्स के बीच सिंक्रनाइज़ेशन की आवश्यकता है। इसलिए, एक धागे का इंतजार करना पड़ता है, जब तक कि दूसरे धागे को निष्पादित नहीं किया जाता है। इसलिए, इस राज्य को प्रतीक्षा राज्य कहा जाता है।
5. मृत: यह वह अवस्था है जब धागा समाप्त हो जाता है। धागा चालू स्थिति में है और जैसे ही यह प्रसंस्करण पूरा हुआ यह "मृत अवस्था" में है।

धागे के लिए आमतौर पर इस्तेमाल किए जाने वाले कुछ तरीके हैं:

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

उदाहरण: इस उदाहरण में हम एक धागा बनाने जा रहे हैं और थ्रेड के लिए उपलब्ध तरीकों का पता लगा सकते हैं।

पैकेज डिमोटेस्ट;सार्वजनिक वर्ग थ्रेड_एक्सप्ल 1 को लागू करता है@ ऑवरराइडसार्वजनिक शून्य रन () {}सार्वजनिक स्थैतिक शून्य main (String [] args) {थ्रेड guruthread1 = नया थ्रेड ();guruthread1.start ();प्रयत्न {guruthread1.sleep (1000);} कैच (बाधित)// TODO ऑटो-जनरेट कैच ब्लॉकe.printStackTrace ();}guruthread1.setPriority (1);int gurupriority = guruthread1.getPriority ();System.out.println (गुरुपरायणता);System.out.println ("थ्रेड रनिंग");}}

कोड की व्याख्या:

• कोड लाइन 2: हम एक वर्ग "थ्रेड_एक्सप्ल 1" बना रहे हैं, जो रननेबल इंटरफ़ेस को लागू कर रहा है (इसे किसी भी वर्ग द्वारा लागू किया जाना चाहिए, जिसका उदाहरण थ्रेड द्वारा निष्पादित किया जाना है।)
• कोड लाइन 4: यह रनवेबल इंटरफ़ेस की रन विधि को ओवरराइड करता है क्योंकि उस पद्धति को ओवरराइड करना अनिवार्य है
• कोड लाइन 6: यहां हमने मुख्य विधि को परिभाषित किया है जिसमें हम थ्रेड का निष्पादन शुरू करेंगे।
• कोड लाइन 7: यहां हम एक नए थ्रेड नाम के रूप में "guruthread1" बना रहे हैं, जो थ्रेड के एक नए वर्ग को इंस्टेंट करके।
• कोड लाइन 8: हम "guruthread1" उदाहरण का उपयोग करके धागे की "स्टार्ट" विधि का उपयोग करेंगे। यहां धागा निष्पादित करना शुरू कर देगा।
• कोड लाइन 10: यहां हम "guruthread1" उदाहरण का उपयोग करके धागे की "नींद" विधि का उपयोग कर रहे हैं। इसलिए, धागा 1000 मिलीसेकंड के लिए सो जाएगा।
• कोड 9-14: यहाँ हमने स्लीप मेथड को ट्रायल कैच ब्लॉक में रखा है क्योंकि जाँच अपवाद है जो तब होता है अर्थात बाधित अपवाद।
• कोड लाइन 15: यहां हम थ्रेड की प्राथमिकता को 1 पर सेट कर रहे हैं जो भी प्राथमिकता थी
• कोड लाइन 16: यहां हमें getPyerity () का उपयोग करके थ्रेड की प्राथमिकता मिल रही है
• कोड लाइन 17: यहां हम getPriority से प्राप्त मूल्य को प्रिंट कर रहे हैं
• कोड लाइन 18: यहां हम एक टेक्स्ट लिख रहे हैं जो थ्रेड चल रहा है।

जब आप उपरोक्त कोड निष्पादित करते हैं, तो आपको निम्न आउटपुट मिलते हैं:

आउटपुट:

5 थ्रेड प्राथमिकता है, और थ्रेड रनिंग वह टेक्स्ट है जो हमारे कोड का आउटपुट है।

जावा थ्रेड सिंक्रोनाइज़ेशन

मल्टीथ्रेडिंग में, कार्यक्रमों का अतुल्यकालिक व्यवहार है। यदि एक थ्रेड कुछ डेटा लिख ​​रहा है और दूसरा थ्रेड जो उसी समय डेटा पढ़ रहा है, हो सकता है कि वह एप्लिकेशन में असंगति पैदा करे।

जब दो या अधिक थ्रेड्स द्वारा साझा संसाधनों तक पहुंचने की आवश्यकता होती है, तो सिंक्रनाइज़ेशन दृष्टिकोण का उपयोग किया जाता है।

जावा ने सिंक्रनाइज़ व्यवहार को लागू करने के लिए सिंक्रनाइज़ तरीके प्रदान किए हैं।

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

इस तरह, सिंक्रनाइज़ेशन एक मल्टीथ्रेडेड एप्लिकेशन में मदद करता है। एक थ्रेड को तब तक इंतजार करना पड़ता है जब तक कि अन्य थ्रेड अपना निष्पादन पूरा नहीं कर लेते हैं तब तक दूसरे थ्रेड्स को निष्पादन की अनुमति दी जाती है।

इसे निम्नलिखित रूप में लिखा जा सकता है:

सिंक्रनाइज़ (ऑब्जेक्ट){{// बयानों को ब्लॉक किया जाना है}

जावा मल्टीथ्रेडिंग उदाहरण

इस उदाहरण में, हम दो थ्रेड्स लेंगे और थ्रेड के नाम प्राप्त करेंगे।

उदाहरण 1:

गुरुथ्र्ड १.जवापैकेज डिमोटेस्ट;सार्वजनिक वर्ग/ *** @ अपरम अर्ग* /सार्वजनिक स्थैतिक शून्य main (String [] args) {थ्रेड गुरुट्रेड 1 = नया थ्रेड ("गुरु 1");थ्रेड गुरुट्रेड 2 = नया थ्रेड ("गुरु 2");guruThread1.start ();guruThread2.start ();System.out.println ("थ्रेड नाम निम्नलिखित हैं:");System.out.println (guruThread1.getName ());System.out.println (guruThread2.getName ());}@ ऑवरराइडसार्वजनिक शून्य रन () {}}

कोड की व्याख्या:

• कोड लाइन 3: हमने एक वर्ग लिया है "GuruThread1" जो रननेबल को लागू करता है (इसे किसी भी वर्ग द्वारा लागू किया जाना चाहिए जिसका उदाहरण थ्रेड द्वारा निष्पादित किया जाना है।)
• कोड लाइन 8: यह कक्षा का मुख्य तरीका है
• कोड लाइन 9: यहां हम थ्रेड क्लास को इंस्टेंट कर रहे हैं और "गुरुथ्रेड 1" नाम से एक इंस्टेंस बना रहे हैं और एक थ्रेड बना रहे हैं।
• कोड लाइन 10: यहां हम थ्रेड क्लास को इंस्टेंट कर रहे हैं और "गुरुथ्रेड 2" नामक एक उदाहरण बना रहे हैं और एक धागा बना रहे हैं।
• कोड लाइन 11: हम थ्रेड शुरू कर रहे हैं अर्थात् गुरुथ्रेड 1।
• कोड लाइन 12: हम थ्रेड शुरू कर रहे हैं अर्थात् गुरुथ्रेड 2।
• कोड लाइन 13: "थ्रेड नाम निम्नलिखित हैं:"
• कोड लाइन 14: थ्रेड क्लास के getName () का उपयोग करके थ्रेड 1 का नाम प्राप्त करना।
• कोड लाइन 15: थ्रेड क्लास के getName () का उपयोग करके थ्रेड 2 का नाम प्राप्त करना।

जब आप उपरोक्त कोड निष्पादित करते हैं, तो आपको निम्न आउटपुट मिलते हैं:

आउटपुट:

थ्रेड नाम के रूप में यहाँ उत्पादन किया जा रहा है

• गुरु १
• गुरु २

उदाहरण 2:

इस उदाहरण में, हम एक रन करने योग्य इंटरफ़ेस के ओवरराइड करने के तरीकों () और स्टार्ट () विधि के बारे में जानेंगे और उस वर्ग के दो धागे बना सकते हैं और उनके अनुसार चल सकते हैं।

इसके अलावा, हम दो कक्षाएं ले रहे हैं,

• एक जो रन करने योग्य इंटरफ़ेस को लागू करेगा और
• एक और जो मुख्य विधि होगी और उसी के अनुसार निष्पादित होगी।

पैकेज डिमोटेस्ट;सार्वजनिक वर्गसार्वजनिक स्थैतिक शून्य main (String [] args) {// TODO ऑटो-जनरेट विधि ठूंठगुरुथ्रेड 3 थ्रेडगुरु 1 = नया गुरुथ्रेड 3 ("गुरु 1");threadguru1.start ();गुरुथ्रेड 3 थ्रेडगुरु 2 = नया गुरुथ्रेड 3 ("गुरु 2");threadguru2.start ();}}क्लास गुरुथ्रेड 3 इम्प्लीमेंट रननीयेबल {धागा गुरुथ्रेड;निजी स्ट्रिंग गुरुनाम;गुरुथ्रेड 3 (स्ट्रिंग नाम) {गुरुनमे = नाम;}@ ऑवरराइडसार्वजनिक शून्य रन () {System.out.println ("थ्रेड रनिंग" + गुरुनाम);for (int i = 0; मैं <4; i ++) {System.out.println (i);System.out.println (guruname);प्रयत्न {थ्रेड.स्लीप (1000);} कैच (बाधित)System.out.println ("थ्रेड बाधित किया गया है");}}}सार्वजनिक शून्य प्रारंभ () {System.out.println ("थ्रेड प्रारंभ");अगर (गुरुथ्रेड == अशक्त) {guruthread = नया सूत्र (यह, गुरुनाम);guruthread.start ();}}}

कोड की व्याख्या:

• कोड लाइन 2: यहां हम एक क्लास ले रहे हैं "GuruThread2", जिसमें इसकी मुख्य विधि होगी।
• कोड लाइन 4: यहां हम क्लास का एक मुख्य तरीका ले रहे हैं।
• कोड लाइन 6-7: यहां हम "थ्रेडगुरु 1" के रूप में क्लास गुरुथ्रेड 3 (जो कोड के नीचे लाइनों में बनाया गया है) का एक उदाहरण बना रहे हैं और हम थ्रेड शुरू कर रहे हैं।
• कोड लाइन 8-9: यहाँ हम "थ्रेडगुरु 2" के रूप में क्लास गुरुथ्रेड 3 (जो कोड के नीचे लाइनों में बनाया गया है) का एक और उदाहरण बना रहे हैं और हम थ्रेड शुरू कर रहे हैं।
• कोड लाइन 11: यहाँ हम एक क्लास बना रहे हैं "GuruThread3" जो रन करने योग्य इंटरफ़ेस को लागू कर रहा है (इसे किसी भी वर्ग द्वारा लागू किया जाना चाहिए जिसका उद्देश्य थ्रेड द्वारा निष्पादित किया जाना है।)
• कोड लाइन 13-14: हम दो क्लास वेरिएबल्स ले रहे हैं, जिसमें से एक थ्रेड क्लास का है और दूसरा स्ट्रिंग क्लास का।
• कोड लाइन 15-18: हम गुरुट्रैड 3 कंस्ट्रक्टर को ओवरराइड कर रहे हैं, जो एक तर्क को स्ट्रिंग प्रकार (जो थ्रेड्स नेम है) के रूप में लेता है जो क्लास वेरिएबल गुरुनाम को सौंपा जाता है और इसलिए थ्रेड का नाम संग्रहीत होता है।
• कोड लाइन 20: यहां हम रन करने योग्य इंटरफ़ेस की रन () विधि को ओवरराइड कर रहे हैं।
• कोड लाइन 21: हम Println स्टेटमेंट का उपयोग करके थ्रेड नाम को आउटपुट कर रहे हैं।
• कोड लाइन 22-31: यहाँ हम 0 के इनिशियलाइज़ किए गए काउंटर के साथ लूप के लिए उपयोग कर रहे हैं, और यह 4 से कम नहीं होना चाहिए (हम किसी भी संख्या को ले सकते हैं इसलिए यहाँ लूप 4 बार चलेगा) और काउंटर को बढ़ाना। हम थ्रेड नाम को प्रिंट कर रहे हैं और थ्रेड स्लीप को 1000 मिसेकंड के लिए ट्राइ-कैच ब्लॉक के भीतर बना रहे हैं, क्योंकि स्लीप मेथड ने अपवाद को उठाया।
• कोड लाइन 33: यहां हम रन करने योग्य इंटरफ़ेस की प्रारंभ विधि को ओवरराइड कर रहे हैं।
• कोड लाइन 35: हम "थ्रेड स्टार्ट" टेक्स्ट को आउटपुट कर रहे हैं।
• कोड लाइन 590 : यहां हम यह जांचने के लिए एक शर्त ले रहे हैं कि क्या कक्षा चर गुरुथ्रेड में इसका मूल्य है या नहीं। यदि इसकी अशक्तता है तो हम थ्रेड क्लास का उपयोग करके एक उदाहरण बना रहे हैं जो एक पैरामीटर के रूप में नाम लेता है (जिसके लिए निर्माण में निर्दिष्ट किया गया था)। जिसके बाद थ्रेड स्टार्ट () विधि का उपयोग करके शुरू किया जाता है।

जब आप उपरोक्त कोड निष्पादित करते हैं तो आपको निम्न आउटपुट मिलते हैं:

आउटपुट :

दो धागे हैं इसलिए, हमें दो बार संदेश मिलता है "थ्रेड शुरू"।

जैसा कि हमने उन्हें आउटपुट किया है, हमें धागे के नाम मिलते हैं।

यह लूप के लिए जाता है जहां हम काउंटर और थ्रेड नाम को प्रिंट कर रहे हैं और काउंटर 0 से शुरू होता है।

लूप तीन बार निष्पादित होता है और धागे के बीच में 1000 मिलीसेकेंड के लिए सोया जाता है।

इसलिए, पहले, हम गुरु 1 को फिर गुरु 2 और फिर गुरु 2 प्राप्त करते हैं क्योंकि धागा यहाँ 1000 मिलीसेकंड के लिए सोता है और फिर अगले गुरु 1 और फिर गुरु 1 में, धागा 1000 मिलीसेकंड के लिए सोता है, इसलिए हमें गुरु 2 और फिर गुरु 1 मिलता है।

सारांश :

इस ट्यूटोरियल में, हमने जावा में मल्टीथ्रेडेड एप्लिकेशन को देखा और सिंगल और मल्टी थ्रेड्स का उपयोग कैसे करें।

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