गो में समवर्तीता और मल्टीथ्रेडिंग: गोरूटीन और चैनल

गो में समवर्तीता का परिचय

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

इस लेख में हम समझेंगे:

• गोरूटीन क्या हैं और उन्हें कैसे चलाएं
• गोरूटीन के बीच डेटा आदान-प्रदान के लिए चैनल
• साझा संसाधनों तक सुरक्षित पहुंच के लिए म्यूटेक्स
• समवर्ती कोड के व्यावहारिक उदाहरण और पैटर्न

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

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

उदाहरण: गोरूटीन शुरू करना

package main

import (    "fmt"    "time")

func sayHello(name string) {    for i := 0; i < 3; i++ {        fmt.Printf("नमस्ते, %s! (पुनरावृत्ति %d)", name, i)        time.Sleep(100 * time.Millisecond)    }}

func main() {    go sayHello("अलीसा")  // गोरूटीन शुरू करना    go sayHello("बॉब")    // एक और गोरूटीन    time.Sleep(1 * time.Second) // पूरा होने की प्रतीक्षा    fmt.Println("मुख्य फ़ंक्शन समाप्त")}

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

sync.WaitGroup का उपयोग

package main

import (    "fmt"    "sync")

func worker(id int, wg *sync.WaitGroup) {    defer wg.Done() // समाप्त होने पर काउंटर घटाएं    fmt.Printf("कार्यकर्ता %d ने काम शुरू किया", id)    // ... कुछ काम ...    fmt.Printf("कार्यकर्ता %d ने काम समाप्त किया", id)}

func main() {    var wg sync.WaitGroup

    for i := 1; i <= 3; i++ {        wg.Add(1) // गोरूटीन शुरू करने से पहले काउंटर बढ़ाएं        go worker(i, &wg)    }

    wg.Wait() // सभी गोरूटीन के समाप्त होने तक main को ब्लॉक करें    fmt.Println("सभी कार्यकर्ताओं ने काम समाप्त कर लिया")}

2. चैनल: गोरूटीन के बीच डेटा आदान-प्रदान

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

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

package main

import "fmt"

func main() {    // पूर्णांकों के लिए चैनल बनाएं    ch := make(chan int)

    // गोरूटीन शुरू करें जो डेटा भेजता है    go func() {        ch <- 42 // चैनल में मान भेजें    }()

    // चैनल से मान प्राप्त करें    value := <-ch    fmt.Println("प्राप्त:", value)}

डिफ़ॉल्ट रूप से चैनल अनबफ़र्ड होते हैं: भेजना तब तक ब्लॉक होता है जब तक प्राप्तकर्ता डेटा लेने के लिए तैयार न हो, और इसके विपरीत। यह सिंक्रनाइज़ेशन सुनिश्चित करता है।

बफ़र्ड चैनल

package main

import "fmt"

func main() {    // 3 तत्वों के बफर वाला चैनल    ch := make(chan string, 3)

    // बिना ब्लॉकिंग के भेजें (जब तक बफर भर न जाए)    ch <- "एक"    ch <- "दो"    ch <- "तीन"

    // पढ़ें    fmt.Println(<-ch)    fmt.Println(<-ch)    fmt.Println(<-ch)}

चैनल बंद करना और range

package main

import "fmt"

func fibonacci(n int, ch chan int) {    a, b := 0, 1    for i := 0; i < n; i++ {        ch <-