कुछ हद तक अपमानजनक शीर्षक के साथ इस पोस्ट में आपका स्वागत है।
लेकिन, इस पोस्ट में मैं आपको इस बार अपनी पसंदीदा प्रोग्रामिंग भाषा GOLANG का उपयोग करके बहुत ही सरल तरीके से समझाना चाहता हूं कि प्रोग्रामिंग की ये 2 विशेषताएं क्या हैं।

आइए एक रसोईघर की कल्पना करें:

एक व्यंजन पकाएं: यह एक कार्य का प्रतिनिधित्व करता है।
एक रसोइया: वह एक प्रोसेसर है।
सहमति:

रसोई में कई रसोइये: हर कोई एक अलग व्यंजन तैयार कर रहा है।
इन गो: प्रत्येक रसोइया एक गोरौटाइन होगा। हालाँकि रसोई (प्रोसेसर) में केवल एक ओवन होता है, रसोइया अपने व्यंजनों पर एक साथ काम कर सकते हैं, ओवन उपलब्ध होने की प्रतीक्षा करते हुए अन्य कार्यों पर समय बिता सकते हैं।
समानांतरता:

विभिन्न ओवन: प्रत्येक रसोइया का अपना ओवन होता है।
इन गो: यदि हमारे पास कई भौतिक प्रोसेसर हैं, तो प्रत्येक गोरोइन एक अलग प्रोसेसर पर चल सकता है, वास्तविक जीवन में एक ही समय में कई व्यंजन पका सकता है।

क्या फर्क पड़ता है?

Concurrency: कार्यों को एक-दूसरे से गुंथकर निष्पादित किया जाता है, जिससे एक ही प्रोसेसर पर भी समानता का भ्रम होता है।
समानांतरवाद: कार्य कई प्रोसेसर पर एक साथ चलते हैं, जिससे प्रक्रिया काफी तेज हो जाती है।

गो में उनका उपयोग कैसे करें?

गोरआउटिंस: वे हल्के धागे की तरह हैं। गोरआउटाइन बनाने के लिए, हम किसी फ़ंक्शन से पहले बस गो कीवर्ड का उपयोग करते हैं:

आइए एक उदाहरण देखें कि हम गोलांग में गोरोइन का उपयोग कैसे कर सकते हैं:

go func() {
    // Código que se ejecutará en una goroutine
}()

चैनल: ये पाइप हैं जिनके माध्यम से गोरोइन संचार और सिंक्रनाइज़ कर सकते हैं।
कल्पना करें कि वे रसोइयों के बीच सामग्री को पारित करने के लिए ट्यूब हैं

ch := make(chan int)
go func() {
    ch 



व्यावहारिक उदाहरण:


package main

import (
    "fmt"
    "time"
)

func worker(id int, c chan int) {
    for n := range c {
        fmt.Printf("Worker %d received %d\n", id, n)
        time.Sleep(time.Second)
    }
}

func main() {
    c := make(chan int)

    for i := 1; i 



इस कोड का आउटपुट होगा


Worker 1 received 1
Worker 2 received 2
Worker 3 received 3
Worker 4 received 4
Worker 5 received 5
Worker 1 received 6
Worker 2 received 7
Worker 3 received 8
Worker 4 received 9
Worker 5 received 10




हालाँकि कभी-कभी यह इस तरह दिख सकता है


Worker 5 received 1
Worker 1 received 3
Worker 2 received 2
Worker 4 received 5
Worker 3 received 4
Worker 3 received 6
Worker 5 received 10
Worker 2 received 8
Worker 4 received 7
Worker 1 received 9




या इस तरह


Worker 5 received 1
Worker 1 received 2
Worker 2 received 3
Worker 3 received 4
Worker 4 received 5
Worker 1 received 6
Worker 2 received 7
Worker 3 received 8
Worker 5 received 9
Worker 4 received 10




हर बार जब मैं प्रोग्राम चलाता हूं तो आउटपुट क्यों बदल जाता है?

प्रत्येक निष्पादन के साथ प्रोग्राम आउटपुट में बदलाव का मुख्य कारण समवर्तीता की गैर-नियतात्मक प्रकृति है।

जो कुछ हो रहा है उसका विवरण यहां दिया गया है:

एक चैनल बनाएं: make(chan int) पूर्णांकों का एक चैनल बनाता है। इस चैनल का उपयोग गोरआउट्स के बीच संचार के लिए किया जाएगा।

गोरोइन प्रारंभ करें: i के लिए लूप:= 1; मैं 
वर्कर फ़ंक्शन आईडी और चैनल प्राप्त करता है।

चैनल को मान भेजें: n के लिए लूप:= 1; एन 1 से 10 तक मान भेजता है।

चैनल बंद करें: क्लोज़(सी) कॉल चैनल को बंद कर देती है, यह दर्शाता है कि कोई और मान नहीं भेजा जाएगा।

चैनल से मान प्राप्त करें: प्रत्येक गोरआउटिन for n := रेंज सी लूप का उपयोग करके चैनल से मान प्राप्त करता है। जब कोई मान प्राप्त होता है, तो उसे कंसोल पर मुद्रित किया जाता है।

गोरआउटिन समाप्त होने तक प्रतीक्षा करें: टाइम.स्लीप(समय.सेकंड) कॉल यह सुनिश्चित करती है कि मुख्य गोरआउटिन बाहर निकलने से पहले अन्य गोरआउटिन समाप्त होने की प्रतीक्षा करता है।

अब तक:

हम 5 गोरौटाइन (रसोइया) बनाते हैं जो एक चैनल के माध्यम से नंबर प्राप्त करते हैं।

हम रसोइयों की प्रक्रिया के लिए चैनल को नंबर भेजते हैं।

रसोइये समवर्ती रूप से काम करते हैं, संख्याओं को प्राप्त करते ही उन्हें संसाधित करते हैं।

गो में समवर्ती और समानता का उपयोग क्यों करें?

बेहतर प्रदर्शन: विशेष रूप से I/O-बाउंड कार्यों में (जैसे फ़ाइलें पढ़ना या HTTP अनुरोध करना)।
बढ़ी हुई प्रतिक्रिया: कार्य अवरुद्ध होने पर एप्लिकेशन अन्य अनुरोधों का जवाब देना जारी रख सकता है।
अधिक स्केलेबल आर्किटेक्चर: आप कई कोर या मशीनों में काम वितरित कर सकते हैं।

याद करना!

संगति और समानता शक्तिशाली उपकरण हैं, लेकिन वे कोड को समझने और डीबग करने के लिए अधिक जटिल भी बना सकते हैं। उनका सावधानीपूर्वक उपयोग करना और उनके निहितार्थ को समझना महत्वपूर्ण है।

क्या आप किसी विशिष्ट विषय की गहराई में जाना चाहते हैं?

हम इस तरह की अवधारणाओं का पता लगा सकते हैं:

सिंक्रनाइज़ेशन: म्यूटेक्स, कार्य समूह, आदि।

समवर्ती पैटर्न: निर्माता-उपभोक्ता, पाइपलाइन, आदि।

समवर्ती परीक्षण: समवर्ती कोड का प्रभावी ढंग से परीक्षण कैसे करें।

अभिवादन,

लुकाटनी राउडेल्स

एक्स/ट्विटर

जीथब