Go में एसिंक्रोनस प्रोग्रामिंग: शुरुआती लोगों के लिए पूर्ण गाइड

Go में एसिंक्रोनस प्रोग्रामिंग: शुरुआती लोगों के लिए पूर्ण गाइड

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

Goroutines क्या हैं और वे थ्रेड्स से कैसे भिन्न हैं?

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

Goroutine शुरू करना बहुत आसान है - बस फंक्शन कॉल से पहले कीवर्ड go जोड़ें:

package main\n\nimport (\n    "fmt"\n    "time"\n)\n\nfunc sayHello() {\n    fmt.Println("Goroutine से नमस्ते!")\n}\n\nfunc main() {\n    go sayHello() // Goroutine शुरू करना\n    time.Sleep(100 * time.Millisecond) // Goroutine के निष्पादित होने की प्रतीक्षा करें\n    fmt.Println("मुख्य फंक्शन समाप्त")\n}

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

WaitGroup के साथ सिंक्रोनाइज़ेशन

Goroutines के पूरा होने की प्रतीक्षा करने का सबसे सरल तरीका sync.WaitGroup का उपयोग करना है। यह एक काउंटर की तरह काम करता है: हम goroutine शुरू करते समय इसे बढ़ाते हैं और पूरा होने पर घटाते हैं। मुख्य फंक्शन तब तक ब्लॉक रहता है जब तक काउंटर शून्य नहीं हो जाता।

package main\n\nimport (\n    "fmt"\n    "sync"\n    "time"\n)\n\nfunc worker(id int, wg *sync.WaitGroup) {\n    defer wg.Done() // पूरा होने पर काउंटर घटाएँ\n    fmt.Printf("कार्यकर्ता %d ने काम शुरू किया\\n", id)\n    time.Sleep(time.Second)\n    fmt.Printf("कार्यकर्ता %d ने काम समाप्त किया\\n", id)\n}\n\nfunc main() {\n    var wg sync.WaitGroup\n\n    for i := 1; i <= 3; i++ {\n        wg.Add(1) // शुरू करने से पहले काउंटर बढ़ाएँ\n        go worker(i, &wg)\n    }\n\n    wg.Wait() // सभी goroutines के पूरा होने की प्रतीक्षा करें\n    fmt.Println("सभी कार्यकर्ताओं ने काम समाप्त कर लिया")\n}

ध्यान दें: wg.Add(1) को goroutine शुरू करने से पहले कॉल किया जाता है, और wg.Done() को इसके अंदर (आमतौर पर defer के माध्यम से)। यह सुनिश्चित करता है कि पैनिक होने पर भी काउंटर सही ढंग से घटाया जाएगा।

Channels: Goroutines के बीच संचार

Channels (channels) टाइप किए गए "पाइप" हैं जिनके माध्यम से goroutines सुरक्षित रूप से डेटा का आदान-प्रदान कर सकते हैं। Channels डिफ़ॉल्ट रूप से सिंक्रोनाइज़ेशन प्रदान करते हैं: channel में भेजना goroutine को तब तक ब्लॉक करता है जब तक कोई अन्य goroutine मान नहीं पढ़ लेता, और इसके विपरीत।

Channels फंक्शन make के साथ बनाए जाते हैं:

package main\n\nimport "fmt"\n\nfunc main() {\n    // पूर्णांकों के लिए एक अनबफ़र्ड channel बनाएँ\n    ch := make(chan int)\n\n    // एक goroutine शुरू करें जो डेटा भेजता है\n    go func() {\n        ch <- 42 // channel में मान भेजें\n    }()\n\n    // channel से पढ़ें (मान आने तक ब्लॉक रहता है)\n    value := <-ch\n    fmt.Println("प्राप्त मान:", value)\n}

Channels दो प्रकार के होते हैं:

\n
• अनबफ़र्ड — सिंक्रोनस, भेजना प्राप्त होने तक ब्लॉक रहता है।
\n
• बफ़र्ड — एसिंक्रोनस, भेजना केवल तब ब्लॉक होता है जब बफ़र भर जाता है।
\n

// 3 तत्वों के लिए बफ़र्ड channel बनाना\nbufferedCh := make(chan string, 3)\nbufferedCh <- "A"\nbufferedCh <- "B"\nbufferedCh <- "C" // जब तक भरा न हो, ब्लॉक नहीं करता