🐡 🐣 🛌🏽 लर्निंग मल्टीथ्रेडेड गो प्रोग्रामिंग चित्रों के साथ 🧚🏼 🏘️ 😺

सबसे अधिक संभावना है, आपने पहले ही गो प्रोग्रामिंग भाषा के बारे में सुना है, इसकी लोकप्रियता लगातार बढ़ रही है, जो काफी उचित है। यह भाषा सरल, तेज है और एक महान समुदाय पर निर्भर करती है। भाषा के सबसे उत्सुक पहलुओं में से एक बहु-थ्रेडेड प्रोग्रामिंग मॉडल है। इसमें अंतर्निहित प्राइमेटिक्स आपको आसानी से और बस बहु-थ्रेडेड प्रोग्राम बनाने की अनुमति देते हैं। यह लेख उन लोगों के लिए अभिप्रेत है जो इन आदिमताओं को सीखना चाहते हैं: गोरोनाइट और चैनल। और, चित्र के माध्यम से, मैं दिखाऊंगा कि उनके साथ कैसे काम करना है। मुझे आशा है कि यह आपके आगे के अध्ययन में आपके लिए एक अच्छी मदद होगी।

एकल और बहु-थ्रेडेड प्रोग्राम

आप संभवतः पहले से ही एकल-थ्रेडेड प्रोग्राम लिख चुके हैं। आमतौर पर यह इस तरह दिखता है: विभिन्न कार्यों को करने के लिए कार्यों का एक सेट होता है, प्रत्येक फ़ंक्शन को केवल तब कहा जाता है जब पिछले एक ने इसके लिए डेटा तैयार किया हो। इस प्रकार, कार्यक्रम क्रमिक रूप से चलता है।

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

इस उदाहरण में, सभी कार्य एक थ्रेड (गैरी गोफर) द्वारा किया जाता है। तीन मुख्य कार्य: खोज, उत्पादन और प्रसंस्करण क्रमिक रूप से एक के बाद एक किए जाते हैं।

func main() { theMine := [5]string{"rock", "ore", "ore", "rock", "ore"} foundOre := finder(theMine) minedOre := miner(foundOre) smelter(minedOre) }

यदि हम प्रत्येक फ़ंक्शन का परिणाम प्रिंट करते हैं, तो हमें निम्नलिखित मिलते हैं:

 From Finder: [ore ore ore] From Miner: [minedOre minedOre minedOre] From Smelter: [smeltedOre smeltedOre smeltedOre]

सरल डिजाइन और कार्यान्वयन एकल-थ्रेडेड दृष्टिकोण का एक प्लस है। लेकिन क्या होगा अगर आप स्वतंत्र रूप से एक-दूसरे को चलाने और निष्पादित करना चाहते हैं? यहां मल्टीथ्रेड प्रोग्रामिंग आपकी सहायता के लिए आती है।

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

Gorutiny

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

 func main() { theMine := [5]string{"rock", "ore", "ore", "rock", "ore"} go finder1(theMine) go finder2(theMine) <-time.After(time.Second * 5) //       }

हमारे कार्यक्रम का आउटपुट निम्नानुसार होगा:

 Finder 1 found ore! Finder 2 found ore! Finder 1 found ore! Finder 1 found ore! Finder 2 found ore! Finder 2 found ore!

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

चैनलों

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

चैनल को पढ़ना और लिखना तीर ऑपरेटर (<-) का उपयोग करके किया जाता है, जो डेटा आंदोलन की दिशा को इंगित करता है।

 myFirstChannel := make(chan string) myFirstChannel <- "hello" //    myVariable := <- myFirstChannel //

अब हमारे गोफर-स्काउट को अयस्क जमा करने की आवश्यकता नहीं है, वह तुरंत चैनलों का उपयोग करके इसे स्थानांतरित कर सकता है।

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

 func main() { theMine := [5]string{“ore1”, “ore2”, “ore3”} oreChan := make(chan string) //   go func(mine [5]string) { for _, item := range mine { oreChan <- item // } }(theMine) //   go func() { for i := 0; i < 3; i++ { foundOre := <-oreChan // fmt.Println(“Miner: Received “ + foundOre + “ from finder”) } }() <-time.After(time.Second * 5) //     }

नीचे दिया गया निष्कर्ष स्पष्ट रूप से दर्शाता है कि हमारे मिनेर को एक बार में चैनल अयस्क एक भाग से तीन बार प्राप्त होता है।

 Miner: Received ore1 from finder Miner: Received ore2 from finder Miner: Received ore3 from finder

इसलिए, अब हम अलग-अलग गोरोइनों (गोफर्स) के बीच डेटा ट्रांसफर कर सकते हैं, लेकिन इससे पहले कि हम एक जटिल प्रोग्राम लिखना शुरू करें, चलो चैनलों के कुछ महत्वपूर्ण गुणों को देखें।

अवरुद्ध

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

लॉक लिखो

जब गोरोइन (गोफर) एक चैनल को डेटा भेजता है, तब तक इसे अवरुद्ध कर दिया जाता है जब तक कि कोई अन्य गोरोइन चैनल से डेटा नहीं पढ़ता है।

ताला पढ़ें

किसी चैनल पर लिखते समय लॉकिंग के समान, चैनल से पढ़ते समय गोरोनेटिन को लॉक किया जा सकता है जब तक कि उसे कुछ भी नहीं लिखा जाता है।
यदि ताले, पहली नज़र में, आपको जटिल लगते हैं, तो आप उन्हें दो गोरोइनों (gophers) के बीच "पैसे के हस्तांतरण" के रूप में कल्पना कर सकते हैं। जब एक गोफर धन हस्तांतरण या प्राप्त करना चाहता है, तो उसे लेनदेन में दूसरे भागीदार के लिए इंतजार करना होगा।

चैनलों पर गोरोइन के ताले से निपटने के बाद, आइए दो अलग-अलग प्रकार के चैनलों पर चर्चा करें: बफ़र्ड और अनबर्डर्ड। इस या उस प्रकार को चुनना, हम काफी हद तक कार्यक्रम के व्यवहार को निर्धारित करते हैं।

असंबद्ध चैनल

पिछले सभी उदाहरणों में, हमने सिर्फ ऐसे चैनलों का इस्तेमाल किया। ऐसे चैनलों पर, डेटा का केवल एक टुकड़ा एक बार में प्रेषित किया जा सकता है (अवरुद्ध के साथ, जैसा कि ऊपर वर्णित है)।

बफर चैनल

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

 bufferedChan := make(chan string, 3)

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

 bufferedChan := make(chan string, 3) go func() { bufferedChan <- "first" fmt.Println("Sent 1st") bufferedChan <- "second" fmt.Println("Sent 2nd") bufferedChan <- "third" fmt.Println("Sent 3rd") }() <-time.After(time.Second * 1) go func() { firstRead := <- bufferedChan fmt.Println("Receiving..") fmt.Println(firstRead) secondRead := <- bufferedChan fmt.Println(secondRead) thirdRead := <- bufferedChan fmt.Println(thirdRead) }()

ऐसे कार्यक्रम में आउटपुट ऑर्डर निम्नानुसार होगा:

 Sent 1st Sent 2nd Sent 3rd Receiving.. first second third

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

यह सब एक साथ रखना

इसलिए, गोरोइटिन और चैनलों से लैस, हम गो में मल्टीथ्रेडेड प्रोग्रामिंग के सभी लाभों का उपयोग करके एक कार्यक्रम लिख सकते हैं।

 theMine := [5]string{"rock", "ore", "ore", "rock", "ore"} oreChannel := make(chan string) minedOreChan := make(chan string) //  go func(mine [5]string) { for _, item := range mine { if item == "ore" { oreChannel <- item //   oreChannel } } }(theMine) //  go func() { for i := 0; i < 3; i++ { foundOre := <-oreChannel //   oreChannel fmt.Println("From Finder: ", foundOre) minedOreChan <- "minedOre" //   minedOreChan } }() //  go func() { for i := 0; i < 3; i++ { minedOre := <-minedOreChan //   minedOreChan fmt.Println("From Miner: ", minedOre) fmt.Println("From Smelter: Ore is smelted") } }() <-time.After(time.Second * 5) //

इस तरह के एक कार्यक्रम निम्नलिखित उत्पादन होगा:

 From Finder: ore From Finder: ore From Miner: minedOre From Smelter: Ore is smelted From Miner: minedOre From Smelter: Ore is smelted From Finder: ore From Miner: minedOre From Smelter: Ore is smelted

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

अनाम गोरटिन्स

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

 //   go func() { fmt.Println("I'm running in my own go routine") }()

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

मुख्य कार्य गोरोइन है।

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

 <-time.After(time.Second * 5) //

याद रखें कि चैनल से पढ़ते समय गोरोइन को अवरुद्ध कर दिया जाएगा जब तक कि इसे कुछ नहीं भेजा जाता है? ठीक ऐसा ही तब होता है जब निर्दिष्ट कोड जोड़ा जाता है। मुख्य गोरआउट को अवरुद्ध किया जाएगा, जिससे अन्य गोरआउट को काम करने के लिए 5 सेकंड का समय मिलेगा। यह विधि अच्छी तरह से काम करती है, लेकिन आमतौर पर, सभी गोरआउट्स को पूरा करने के लिए एक अलग दृष्टिकोण का उपयोग किया जाता है। काम पूरा होने के बारे में एक संकेत प्रेषित करने के लिए, एक विशेष चैनल बनाया जाता है, मुख्य गोरोइटन को इसे पढ़ने से रोक दिया जाता है और, जैसे ही बेटी गोरोइन अपना काम पूरा करती है, यह इस चैनल को लिखती है; मुख्य गोरोइन को अनलॉक किया जाता है और कार्यक्रम समाप्त होता है।

 func main() { doneChan := make(chan string) go func() { //  -  doneChan <- “I'm all done!” }() <-doneChan //        }

फॉर-रेंज लूप में एक पाइप से पढ़ें

हमारे उदाहरण में, गोफ़र-गेट्टर के फ़ंक्शन में, हमने चैनल से तीन तत्वों का चयन करने के लिए लूप का उपयोग किया। लेकिन क्या करना है अगर यह पहले से ज्ञात नहीं है कि चैनल में कितना डेटा हो सकता है? ऐसे मामलों में, आप कलेक्शन के साथ ही, फॉर-रेंज लूप के तर्क के रूप में चैनल का उपयोग कर सकते हैं। अद्यतन फ़ंक्शन इस तरह दिख सकता है:

  //  go func() { for foundOre := range oreChan { fmt.Println(“Miner: Received “ + foundOre + “ from finder”) } }()

इस प्रकार, अयस्क खननकर्ता वह सब कुछ पढ़ेगा जो स्काउट उसे भेजता है, चक्र में चैनल का उपयोग करके यह गारंटी देगा। कृपया ध्यान दें कि चैनल से सभी डेटा संसाधित होने के बाद, चक्र पढ़ने पर लॉक हो जाएगा; ब्लॉक से बचने के लिए, आपको चैनल (चैनल) को बंद करके चैनल बंद करने की आवश्यकता है।

नॉन-ब्लॉकिंग चैनल रीडिंग

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

 myChan := make(chan string) go func(){ myChan <- “Message!” }() select { case msg := <- myChan: fmt.Println(msg) default: fmt.Println(“No Msg”) } <-time.After(time.Second * 1) select { case msg := <- myChan: fmt.Println(msg) default: fmt.Println(“No Msg”) }

एक बार लॉन्च होने के बाद, यह कोड निम्नलिखित को आउटपुट करेगा:

 No Msg Message!

नॉन-ब्लॉकिंग चैनल रिकॉर्डिंग

किसी चैनल पर लिखते समय ताले को उसी चुनिंदा केस के निर्माण से बचा जा सकता है। चलो पिछले उदाहरण के लिए एक छोटा सा संपादन करें:

 select { case myChan <- “message”: fmt.Println(“sent the message”) default: fmt.Println(“no message sent”) }

आगे क्या पढ़ना है

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

पढ़ने के लिए समय निकालने के लिए धन्यवाद। मुझे आशा है कि मैंने आपको चैनल, गोरोइनटाइन और बहुस्तरीय कार्यक्रमों के लाभ देने में मदद की है।

लर्निंग मल्टीथ्रेडेड गो प्रोग्रामिंग चित्रों के साथ