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

आप जैसे पाठक MUO को समर्थन देने में मदद करते हैं। जब आप हमारी साइट पर लिंक का उपयोग करके खरीदारी करते हैं, तो हम संबद्ध कमीशन कमा सकते हैं। और पढ़ें।

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

दिन का एमयूओ वीडियो सामग्री जारी रखने के लिए स्क्रॉल करें

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

---

---

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

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

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

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

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

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

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

---

---

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

जिम्प में डीपीआई कैसे बदलें

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

---

---

 func main() { 
    go function1() // Create and execute goroutine for function1 
    go function2() // Create and execute goroutine for function2 
 
    // ... 
} 
 
func function1() { 
    // Code for function1 
} 
 
func function2() { 
    // Code for function2 
} 

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

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

 package main 
 
import ( 
    "fmt" 
    "time" 
) 
 
func printText() { 
    for i := 1; i <= 5; i++ { 
        fmt.Println("Printing text", i) 
        time.Sleep(1 * time.Second) 
    } 
} 
 
func main() { 
    go printText() // Start a goroutine to execute the printText function concurrently 
 
    // Perform other tasks in the main goroutine 
    for i := 1; i <= 5; i++ { 
        fmt.Println("Performing other tasks", i) 
        time.Sleep(500 * time.Millisecond) 
    } 
 
    // Wait for the goroutine to finish 
    time.Sleep(6 * time.Second) 
} 

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

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

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

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

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

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

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

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

 func main() { 
    // Create an unbuffered channel of type string 
    ch := make(chan string) 
 
    // Goroutine 1: Sends a message into the channel 
    go func() { 
        ch <- "Hello, Channel!" 
    }() 
 
    // Goroutine 2: Receives the message from the channel 
    msg := <-ch 
    fmt.Println(msg) // Output: Hello, Channel! 
} 

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

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

 func main() { 
    // Unbuffered channel 
    ch1 := make(chan int) 
 
    // Buffered channel with a capacity of 3 
    ch2 := make(chan string, 3) 
 
    // Sending and receiving values from channels 
    ch1 <- 42 // Send a value into ch1 
    value1 := <-ch1 // Receive a value from ch1 
 
    ch2 <- "Hello" // Send a value into ch2 
    value2 := <-ch2 // Receive a value from ch2 
} 

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

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

 func main() { 
    ch := make(chan bool) 
 
    go func() { 
        fmt.Println("Goroutine 1") 
        ch <- true // Signal completion 
    }() 
 
    go func() { 
        <-ch // Wait for the completion signal from Goroutine 1 
        fmt.Println("Goroutine 2") 
    }() 
 
    <-ch // Wait for completion signal from Goroutine 2 
    fmt.Println("Main goroutine") 
} 

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

क्या आपके फोन के साथ सोना बुरा है

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

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

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