गोरौटाइन

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

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

Goroutines क्या हैं?

एक गोरौटाइन गोलांग में एक सरल कार्यान्वयन धागा है जो बाकी कार्यक्रम के साथ-साथ प्रदर्शन करता है। मानक धागे के समान होने पर Goroutines सस्ते होते हैं क्योंकि गोरौटाइन बनाने की लागत बहुत कम होती है। इसलिए, वे समवर्ती प्रोग्रामिंग के लिए Go में बड़े पैमाने पर कार्यरत हैं। प्रत्येक कार्यक्रम में कम से कम एक गोरोइन होता है जिसे मुख्य गोरोइन कहा जाता है। मुख्य गोरोइन अन्य सभी गोरोइन को नियंत्रित करता है; इस प्रकार, यदि मुख्य गोरोइन समाप्त हो जाता है, तो स्क्रिप्ट में अन्य सभी गोरआउट भी ऐसा ही करते हैं। गोरौटाइन हमेशा बैकग्राउंड में एक्टिव रहता है।

उदाहरण: यहां एक उदाहरण दिया गया है: आप अपनी नोटबुक में कुछ लिख रहे हैं और भूख लग रही है; तुम विश्राम करोगे और कुछ खाओगे। फिर फिर से लिखना शुरू करें। अब आप दो भूमिकाएँ कर रहे हैं (लिखना और खाना) एक समय खिड़की से जिसे समवर्ती रोजगार माना जाता है। इस बात पर प्रकाश डाला जाना चाहिए कि इन दो कार्यों (लिखने और खाने) को अभी भी एक साथ पूरा करने की आवश्यकता है। जब वस्तुओं को एक साथ पूरा किया जाता है, तो इसे समानांतरवाद कहा जाता है (कल्पना कीजिए कि चिप्स चबाते समय अपने सेलफोन का उपयोग करें)। Concurrency में एक साथ कई चीजों के साथ इंटरैक्ट करना शामिल है। समानांतरवाद (एक साथ कई चीजें करना) कुछ समय सारिणी के साथ इसका एक उपवर्ग है (एक ही समय में प्रदर्शन करने की आवश्यकता नहीं है)।

हम फ़ंक्शन कॉल में गो कीवर्ड लागू करके एक गोरोइन जोड़ सकते हैं। एक बार जब हम गो कीवर्ड को फंक्शनिंग कॉल पर लागू कर देते हैं, तो हम प्रदर्शन के लिए समवर्ती सेट कर देंगे। लेकिन पहले, निष्पादन के लिए गो कीवर्ड को लागू करने के प्रभाव की पहचान करें। मान लें कि एक कार्यक्रम में दो गोरोइन हैं। पाठ " package main import " कार्यक्रम की प्रविष्टि होगी। Go में, एक पैकेज मुख्य आयात एक घोषणात्मक आयात विवरण है। मुख्य गोरौटाइन ( first goroutine) निहित है। जब हम गो ( f) निष्पादित करते हैं, तो दूसरा गोरोइन (0) बनता है। आमतौर पर, जब हम अगली पंक्ति में जाने से पहले किसी फ़ंक्शन को निष्पादित करते हैं, तो हमारा सॉफ़्टवेयर प्राथमिक फ़ंक्शन में प्रत्येक कमांड को निष्पादित करेगा।

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

धागों की तुलना में Goroutines के लाभ

Goroutines की कीमत कम है

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

बहुसंकेतन Goroutines हैं

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

चैनलों का उपयोग करके Goroutines संचार करते हैं

चैनलों का उपयोग करके Goroutines बातचीत करते हैं। जब वे प्रासंगिक स्मृति साझा करते हैं तो दौड़ की स्थितियों को होने से रोकने का इरादा है। चैनलों की तुलना उस नाली से की जा सकती है जिसका उपयोग गोरोइन बातचीत करने के लिए करते हैं।

चैनल क्या हैं?

दो गोरोइन एक दूसरे के साथ बातचीत कर सकते हैं और चैनलों पर अपने संचालन का समन्वय कर सकते हैं। यह सॉफ्टवेयर लगातार " ping " प्रिंट करेगा। चैनल फॉर्म को निर्दिष्ट करने के लिए, उपसर्ग " chan " चैनल पर प्रसारित वस्तुओं के साथ है। इस मामले में, हम स्ट्रिंग प्रदान कर रहे हैं। चैनल पर, ऑपरेटर का उपयोग करके संदेश भेजे और प्राप्त किए जाते हैं। " ping " भेजने को संदर्भित करता है एक " ping "।

एक चैनल का उपयोग दो गोरोइन को सिंक में रखने के लिए किया जाता है। पूरे चैनल में संदेश भेजने का प्रयास करने से पहले, राउटर तब तक प्रतीक्षा करेगा जब तक प्रिंटर इसे स्वीकार करने के लिए तैयार न हो जाए। इसके लिए शब्द निषेध है। चैनल बनाते समय, मेक फ़ंक्शन के लिए एक दूसरे पैरामीटर का उपयोग किया जा सकता है: c:= make (chan int, 1)

चैनल की दिशा

हम चैनल फॉर्म के ओरिएंटेशन को परिभाषित कर सकते हैं और इसे प्राप्त करने या प्रसारित करने के लिए पैरामीटर कर सकते हैं। उदाहरण के लिए, पिंजर की विधि चिह्न को इसमें बदला जा सकता है:

func pinger(c chan<- string)

सी अभी भेजा जा सकता है। सी से प्राप्त करने के परिणामस्वरूप कोड त्रुटि होगी। इसी तरह, हम आउटपुट को संशोधित कर सकते हैं:

func printer(c string -chan)

एक अर्ध-चैनल में ये बाधाएँ नहीं होती हैं। एक दो-दिशात्मक चैनल को एक ऐसी प्रक्रिया में आपूर्ति की जा सकती है जो केवल केवल-ट्रांसमिट या केवल-स्वीकार करने वाले चैनलों को स्वीकार करती है, लेकिन दूसरी तरफ नहीं।

गोरआउटिन कैसे बनाते हैं?

गोरोइन लॉन्च करने की विधि सीधी है। गोरोइन बनाने के लिए फ़ंक्शन कॉल में " go " कीवर्ड लागू करें जो समवर्ती रूप से निष्पादित होगा। यहां हम एक गोरौटाइन बनाने जा रहे हैं। मान लीजिए कि हमारे पास दो कार्यों वाला एक कार्यक्रम है: एक स्वागत समारोह है, और दूसरा मुख्य कार्य है।

जब हम एक नया गोरोइन बनाते हैं, तो स्वागत () कोड मुख्य () फ़ंक्शन के साथ निष्पादित होगा। जब आप इस प्रोग्राम को करेंगे तो आप हैरान रह जाएंगे। यह प्रोग्राम केवल मुख्य ऑपरेशन टेक्स्ट दिखाता है। हमारे द्वारा शुरू किए गए पहले गोरोइन या नए गोरोइन का क्या हुआ? यह समझने के लिए कि ऐसा क्यों होता है, हमें पहले गोरोइन की दो प्रमुख विशेषताओं को जानना होगा।

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

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

हमने 1 सेकंड के लिए गोरोइन को रोकने के लिए स्लीप तकनीक ( time.sleep(1 * time.second)) को लागू किया। स्वागत समारोह () में अब मुख्य गोरोइन से बाहर निकलने से पहले पूरा करने के लिए पर्याप्त समय है। यह सॉफ़्टवेयर शुरू में " welcome goroutine " लिखता है और फिर मुख्य फ़ंक्शन को प्रिंट करने से पहले एक सेकंड तक प्रतीक्षा करता है। हम प्राथमिक गोरोइन में स्लीप तकनीक का उपयोग इसे एक पल के लिए रोकने के लिए करते हैं ताकि अन्य गोरोइन को पूरा किया जा सके।

कई Goroutines बनाना

हम कई गोरोइन बनाने के लिए एक और कार्यक्रम शुरू करने जा रहे हैं। हम पहले दो गोरोइन बनाकर शुरू कर सकते हैं जो समानांतर में निष्पादित होंगे। ये दो गोरौटाइन नंबर गोरोटिन हैं [गो नंबर ()] और अल्फाबेट गोरोटिन्स [ go alphabets ()]।

1 प्रिंट करने से पहले गोरौटाइन की संख्या 250 एमएस तक रहती है, 2 प्रिंट करने से पहले फिर से आराम करती है, और इसी तरह जब तक यह 5 उत्पन्न नहीं करती है। इसी तरह, अल्फ़ान्यूमेरिक गोरौटाइन एक से ई तक के अक्षर को प्रदर्शित करता है और फिर 400 मिलीसेकंड की प्रतीक्षा करता है। अंत में, प्राथमिक गोरोइन पूर्णांक और अल्फ़ान्यूमेरिक वर्ण बनाता है और कुछ समय के लिए रुकता है, और फिर मुख्य गोरोइन समाप्त हो जाता है।

बार-बार समवर्ती प्रोग्रामिंग गलतियाँ

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

निष्कर्ष

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

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

AppMaster एक no-code प्लेटफॉर्म है जो मोबाइल और वेब एप्लिकेशन के साथ-साथ बैकएंड बनाने में सक्षम है। एक दिलचस्प तथ्य AppMaster प्रति सेकंड 22,000 लाइनों पर Go द्वारा बैकएंड बनाता है और आप स्रोत कोड तक पहुंच सकते हैं।