Go में एसिंक्रोनस प्रोग्रामिंग: उदाहरणों के साथ पूर्ण गाइड

परिचय: Go में एसिंक्रोनस प्रोग्रामिंग की आवश्यकता क्यों?

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

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

1. गोरूटीन (Goroutines): हल्के थ्रेड

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

गोरूटीन शुरू करना

किसी फ़ंक्शन को गोरूटीन के रूप में चलाने के लिए, फ़ंक्शन कॉल से पहले कीवर्ड go जोड़ें:

package main

import (    "fmt"    "time")

func printNumbers() {    for i := 1; i <= 5; i++ {        fmt.Println(i)        time.Sleep(100 * time.Millisecond)    }}

func main() {    // फ़ंक्शन को गोरूटीन के रूप में चलाएं    go printNumbers()

    // मुख्य गोरूटीन काम करना जारी रखता है    fmt.Println("मुख्य गोरूटीन काम कर रही है")

    // चाइल्ड गोरूटीन को निष्पादित करने का समय दें    time.Sleep(1 * time.Second)    fmt.Println("प्रोग्राम समाप्त")}

महत्वपूर्ण: प्रोग्राम तब समाप्त होता है जब फ़ंक्शन main() समाप्त होता है। यदि मुख्य गोरूटीन पहले समाप्त हो जाती है, तो सभी चाइल्ड गोरूटीन को जबरन रोक दिया जाएगा। इसलिए उदाहरण में हम प्रतीक्षा करने के लिए time.Sleep का उपयोग करते हैं - व्यवहार में, सिंक्रोनाइज़ेशन के लिए चैनल या sync.WaitGroup का उपयोग किया जाता है।

गोरूटीन में अनाम फ़ंक्शन

गोरूटीन अक्सर अनाम फ़ंक्शन के साथ बनाए जाते हैं:

go func() {    fmt.Println("गोरूटीन में निष्पादित हो रहा है")}()

2. चैनल (Channels): गोरूटीन के बीच संचार

चैनल टाइप किए गए "पाइप" हैं जिनके माध्यम से गोरूटीन मान भेज और प्राप्त कर सकते हैं। Go में सिंक्रोनाइज़ेशन और डेटा आदान-प्रदान का यह मुख्य तंत्र है। चैनल स्पष्ट लॉक (म्यूटेक्स) के उपयोग के बिना डेटा तक सुरक्षित पहुंच सुनिश्चित करते हैं।

चैनल बनाना और उपयोग करना

चैनल फ़ंक्शन make() के साथ बनाया जाता है। ऑपरेटर <- का उपयोग डेटा भेजने और प्राप्त करने के लिए किया जाता है:

package main

import "fmt"

func sum(s []int, c chan int) {    total := 0    for _, v := range s {        total += v    }    c <- total // परिणाम चैनल को भेजें}

func main() {    s := []int{7, 2, 8, -9, 4, 0}

    c := make(chan int)    go sum(s[:len(s)/2], c)    go sum(s[len(s)/2:], c)

    x, y := <-c, <-c // चैनल से डेटा प्राप्त करें

    fmt.Println(x, y, x+y)}

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

बफ़र किए गए चैनल

डिफ़ॉल्ट रूप से, चैनल अनबफ़र होते हैं - भेजना तब तक ब्लॉक रहता है जब तक प्राप्तकर्ता मान लेने के लिए तैयार न हो। बफ़र किए गए चैनल में दिए गए आकार की एक कतार होती है:

ch := make(chan int, 2) // 2 तत्वों के बफ़र वाला चैनलch <- 1ch <- 2// ch <- 3 // त्रुटि: deadlock, बफ़र भर गयाfmt.Println(<-ch) // 1fmt.Printl