Go में एसिंक्रोनस प्रोग्रामिंग: डेवलपर्स के लिए पूर्ण गाइड

शुरुआती लोगों के लिए ऑनलाइन Python प्रशिक्षक

Python आसानी से सीखें बिना सिद्धांत के बोझ के। स्वचालित जांच के साथ व्यावहारिक कार्य हल करें और ब्राउज़र में सीधे कोड लिखें।

पाठ्यक्रम शुरू करें

Go में अतुल्यकालिक प्रोग्रामिंग: मूल अवधारणाएँ और अभ्यास

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

1. Goroutines: हल्के निष्पादन थ्रेड

Goroutine एक हल्का निष्पादन थ्रेड है, जो Go रनटाइम द्वारा प्रबंधित होता है। सिस्टम थ्रेड के विपरीत, goroutines में न्यूनतम ओवरहेड होता है। आप प्रदर्शन पर महत्वपूर्ण प्रभाव डाले बिना हजारों goroutines चला सकते हैं।

Goroutine शुरू करने के लिए फंक्शन कॉल से पहले go कीवर्ड का उपयोग किया जाता है:

package main

import (    "fmt"    "time")

func printMessage(msg string) {    for i := 0; i < 5; i++ {        fmt.Println(msg)        time.Sleep(100 * time.Millisecond)    }}

func main() {    // goroutine शुरू करना    go printMessage("अतुल्यकालिक आउटपुट")        // मुख्य थ्रेड काम करता रहता है    printMessage("तुल्यकालिक आउटपुट")        // goroutine को पूरा होने का समय देना    time.Sleep(1 * time.Second)}

याद रखना महत्वपूर्ण है: मुख्य फंक्शन main भी एक goroutine है। यदि यह समाप्त हो जाता है, तो अन्य सभी goroutines नष्ट हो जाएंगी। इसलिए, सिंक्रनाइज़ेशन के लिए अक्सर sync.WaitGroup या channels का उपयोग किया जाता है।

2. Channels: goroutines के बीच सुरक्षित डेटा स्थानांतरण

Channels टाइप किए गए "पाइप" हैं, जिनके माध्यम से goroutines डेटा का आदान-प्रदान कर सकती हैं। मूल सिद्धांत: "साझा मेमोरी के माध्यम से संवाद न करें; संचार के माध्यम से मेमोरी साझा करें"।

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

package main

import "fmt"

func main() {    // int के लिए एक अनबफर्ड चैनल बनाना    ch := make(chan int)        // एक goroutine शुरू करना जो डेटा भेजती है    go func() {        for i := 0; i < 5; i++ {            ch <- i * 2        }        close(ch) // सभी डेटा भेजने के बाद चैनल बंद करना    }()        // चैनल से डेटा पढ़ना    for value := range ch {        fmt.Println("प्राप्त हुआ:", value)    }}

बफर्ड चैनल तत्काल प्राप्त किए बिना डेटा भेजने की अनुमति देते हैं:

ch := make(chan string, 3) // 3 तत्वों के लिए बफरch <- "A"ch <- "B"ch <- "C"// अब पढ़ा जा सकता हैfmt.Println(<-ch) // Afmt.Println(<-ch) // B

3. select स्टेटमेंट: कई channels के साथ काम करना

select स्टेटमेंट एक goroutine को एक साथ कई चैनल ऑपरेशनों की प्रतीक्षा करने की अनुमति देता है। यह तब तक ब्लॉक रहता है जब तक उसका कोई एक केस निष्पादन के लिए तैयार न हो जाए।

टाइमआउट और कई डेटा स्रोतों को संभालने का उदाहरण:

package main

import (    "fmt"    "time")

func worker(id int, ch chan string) {    time.Sleep(time.Duration(id) * time.Second)    ch <- fmt.Sprintf("worker %d से परिणाम", id)}

func main() {    ch1 := make(chan string)    ch2 := make(chan string)        go worker(2, ch1) // 2 सेकंड में पूरा होगा    go worker(3, ch2) // 3 सेकंड में पूरा होगा        select {    case msg1 := <-ch1:        fmt.Println("पहला चैनल:", msg1)    case msg2 := <-ch2:        fmt.Println("दूसरा चैनल:", msg2)    case <-time.After(1 * time.Second):        fmt.Println("टाइमआउट! कोई भी worker समय पर पूरा नहीं हुआ")    }        // लीक को रोकने के लिए चैनल बंद करना    close(ch1)    close(ch2)}

select स्टेटमेंट टाइमआउट, नॉन-ब्लॉकिंग ऑपरेशन और "fan-in" पैटर्न (कई चैनलों को एक में मर्ज करना) को लागू करने के लिए आदर्श है।