गो में कॉनकरेंसी का परिचय

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

कॉन्करेंसी गो के तेजी से अपनाने के लिए जिम्मेदार सुविधाओं में से एक है। समवर्ती प्रोग्रामिंग के लिए गो के अंतर्निहित समर्थन को दौड़ की स्थिति और गतिरोध जैसी सामान्य कठिनाइयों से बचने में मदद करते हुए सीधा माना जाता है।

गो में समवर्तीता

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

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

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

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

समवर्ती कोड निष्पादन के लिए गोरआउट्स का उपयोग कैसे करें

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

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

गोरोइन्ट्स बनाना सीधा है। आप इसका उपयोग करेंगे जाना गोरोइन्स घोषित करने के लिए फ़ंक्शन कॉल के बाद कीवर्ड।

समारोहमुख्य() {
जाना फ़ंक्शन1() // function1 के लिए goroutine बनाएं और निष्पादित करें
जाना फ़ंक्शन2() // function2 के लिए goroutine बनाएं और निष्पादित करें
// ...
}
समारोहफ़ंक्शन1() {
// फ़ंक्शन1 के लिए कोड
}
समारोहFunction2() {
// फ़ंक्शन2 के लिए कोड
}

जब प्रोग्राम प्रारंभ होता है फ़ंक्शन1() और फ़ंक्शन2() साथ जाना कीवर्ड, गो रनटाइम समवर्ती रूप से गोरआउट्स के रूप में कार्यों को निष्पादित करता है।

यहां गोरोइन का एक उदाहरण दिया गया है जो कंसोल पर टेक्स्ट प्रिंट करता है:

पैकेट मुख्य
आयात (
"एफएमटी"
"समय"
)
समारोहप्रिंट टेक्स्ट() {
के लिए मैं := 1; मैं <= 5; मैं++ {
 एफएमटी. Println("मुद्रण पाठ", मैं)
 समय। नींद(1 * समय। दूसरा)
 }
}
समारोहमुख्य() {
जाना प्रिंटटेक्स्ट() // प्रिंटटेक्स्ट फ़ंक्शन को समवर्ती रूप से निष्पादित करने के लिए एक गोरोइन प्रारंभ करें
// मुख्य गोरोइन में अन्य कार्य करें
के लिए मैं := 1; मैं <= 5; मैं++ {
 एफएमटी. Println("अन्य कार्य करना", मैं)
 समय। नींद(500 * समय। मिलीसेकंड)
 }
// गोरोइन खत्म होने तक प्रतीक्षा करें
 समय। नींद(6 * समय। दूसरा)
}

प्रिंट टेक्स्ट फ़ंक्शन बार-बार कुछ टेक्स्ट को कंसोल पर प्रिंट करता है के लिए लूप जो प्रत्येक कथन के बीच एक सेकंड की देरी के बाद पांच बार चलता है समय पैकेज.

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

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

संचार और तुल्यकालन के लिए चैनलों का उपयोग करना

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

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

आप इसका उपयोग करेंगे चैनलों के माध्यम से डेटा भेजने और प्राप्त करने के लिए ऑपरेटर।

यहां दो गोरआउट्स के बीच संचार के लिए चैनलों के बुनियादी उपयोग को प्रदर्शित करने वाला एक उदाहरण दिया गया है:

समारोहमुख्य() {
// प्रकार स्ट्रिंग का एक असंबद्ध चैनल बनाएं
 च:= निर्माण(चानडोरी)
// गोरूटाइन 1: चैनल में एक संदेश भेजता है
जानासमारोह() {
 च "हैलो, चैनल!"
 }()
// गोरोइन 2: चैनल से संदेश प्राप्त करता है
 संदेश :=  एफएमटी. Println (संदेश) // आउटपुट: हैलो, चैनल!
}

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

आप टाइप किए गए चैनल परिभाषित कर सकते हैं. आप निर्माण पर चैनल प्रकार निर्दिष्ट करेंगे। यहां एक उदाहरण दिया गया है जो विभिन्न चैनल प्रकारों के उपयोग को दर्शाता है:

समारोहमुख्य() {
// अनबफ़र्ड चैनल
 ch1 := निर्माण(चानint यहाँ)
// 3 की क्षमता वाला बफर्ड चैनल
 ch2 := निर्माण(चानडोरी, 3)
// चैनलों से मान भेजना और प्राप्त करना
 ch1 42// ch1 में एक मान भेजें
 वैल्यू1 := // ch1 से एक मान प्राप्त करें
 ch2 "नमस्ते"// ch2 में एक मान भेजें
 मान2 := // ch2 से एक मान प्राप्त करें
}

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

आप चैनल संचालन की अवरुद्ध प्रकृति का लाभ उठाकर गोरोइन निष्पादन के समन्वय के लिए चैनलों को सिंक्रनाइज़ेशन तंत्र के रूप में उपयोग कर सकते हैं।

समारोहमुख्य() {
 च:= निर्माण(चानबूल)
जानासमारोह() {
 एफएमटी. Println("गोरौटीन 1")
 च सत्य// सिग्नल पूरा होना
 }()
जानासमारोह() {
 // गोरौटाइन 1 से पूर्णता संकेत की प्रतीक्षा करें
 एफएमटी. Println("गोरौटीन 2")
 }()
 // गोरौटाइन 2 से पूरा होने के संकेत की प्रतीक्षा करें
 एफएमटी. Println("मुख्य गोरौटाइन")
}

चौधरी चैनल बूलियन है. दो गोरोइन एक साथ चलते हैं मुख्य समारोह। गोरौटाइन 1 एक भेजकर इसके पूरा होने का संकेत देता है सत्य चैनल में मूल्य चौधरी. गोरौटाइन 2 चैनल से मान प्राप्त करके पूर्णता संकेत की प्रतीक्षा करता है। अंत में, मुख्य गोरोइनट गोरोइन दो से पूर्णता संकेत की प्रतीक्षा करता है।

आप जिन के साथ गो में वेब ऐप्स बना सकते हैं

आप गो की समवर्ती सुविधाओं का लाभ उठाते हुए गो विद जिन में उच्च प्रदर्शन वाले वेब ऐप्स बना सकते हैं।

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