चैनल: टाइप किया गया संचार

चैनल बीच संचार के लिए मुहावरेदार तंत्र हैं goroutines. गो दर्शन (रॉब पाइक):

"स्मृति साझा करके संवाद न करें; संचार करके स्मृति साझा करें।"

एक चैनल एक टाइप की गई फीफो कतार है, जो टाइप-सुरक्षित और समवर्ती के लिए सुरक्षित है उपयोग करें. go के साथ संयुक्त, यह गो का प्राथमिक निर्माण खंड है समवर्ती।

बनाएं, भेजें, प्राप्त करें

ch := make(chan int)     // canale di int, unbuffered

go func() {
    ch <- 42             // invia (può bloccare)
}()

v := <-ch                // ricevi (può bloccare)
fmt.Println(v)           // 42

सिंटेक्स:

• बफ़र के लिए make(chan T) या make(chan T, N)।
• ch <- v भेजता है।
• v := <-ch प्राप्त होता है।
• v, ok := <-ch एक ध्वज के साथ प्राप्त होता है (ok = false यदि चैनल बंद और खाली है)।

असंबद्ध: मिलन स्थल

एक असंबद्ध चैनल (क्षमता 0) ब्लॉक करता है:

• प्रेषक जब तक रिसीवर तैयार न हो जाए;
• रिसीवर जब तक प्रेषक तैयार न हो जाए।

यह एक समकालिक नियुक्ति है: "सिग्नल" या गारंटी के रूप में उपयोगी कि मूल्य वितरित कर दिया गया है।

बफ़र्ड: N तक कतारबद्ध

ch := make(chan int, 3)
ch <- 1   // non blocca
ch <- 2   // non blocca
ch <- 3   // non blocca
ch <- 4   // BLOCCA: il buffer è pieno

प्रेषक केवल तभी ब्लॉक करता है जब बफ़र भर जाता है; केवल रिसीवर जब यह खाली हो.

बंद करें और सीमा के लिए

कोई और मान न होने पर प्रेषक चैनल बंद कर देता है:

ch := make(chan int, 3)
ch <- 1
ch <- 2
ch <- 3
close(ch)

for v := range ch {      // termina quando ch è chiuso E vuoto
    fmt.Println(v)
}

for range एक चैनल पर तब तक दोहराया जाता है जब तक कि चैनल बंद न हो जाए (और खत्म न हो जाए)। यह "जो कुछ भी आता है उसका उपभोग करें" का सबसे साफ पैटर्न है।

हस्ताक्षरों में दिशात्मकता

फ़ंक्शन पैरामीटर दिशा को प्रतिबंधित कर सकते हैं:

func producer(out chan<- int) {   // solo invio
    out <- 1
    close(out)
}

func consumer(in <-chan int) {    // solo ricezione
    for v := range in {
        fmt.Println(v)
    }
}

chan<- T = केवल भेजें, <-chan T = केवल प्राप्त करें। एक द्विदिश चैनल chan T को किसी एक (अंतर्निहित रूपांतरण) में पास किया जा सकता है। यह स्पष्टता में सुधार करता है और गलतियों को रोकता है।

सामान्य पैटर्न (पूर्वावलोकन)

• वर्कर पूल: एन गोरआउट्स jobs <-chan T से उपभोग करते हैं, results chan<- R पर उत्पादन करते हैं।
• पाइपलाइन: चैनलों द्वारा जुड़े हुए चरण।
• संकेत पूरा हो गया: एक chan struct{} चैनल "स्टॉप" का संकेत देने के लिए बंद हो गया।

done := make(chan struct{})
go func() {
    <-done    // blocca finché qualcuno chiude done
    cleanup()
}()
close(done)   // segnale di stop

chan struct{} "सिग्नल" चैनल है: पेलोड के शून्य बाइट्स, बस तुल्यकालन.

इसे अजमाएं

ch := make(chan int)
ch <- 1 // ?

संक्षिप्त

• चैनल = टाइप की गई फीफो कतार, गोरआउट्स के बीच सुरक्षित।
• अनबफ़र्ड: मिलन स्थल (प्रेषक और रिसीवर सिंक्रनाइज़)।
• बफ़र्ड: डिकॉउलिंग, पूर्ण/खाली होने पर ही ब्लॉक होता है।
• close(ch): केवल प्रेषक; for range बंद होने तक उपभोग करता है।
• दिशात्मकता: chan<- T (केवल भेजें), <-chan T (केवल प्राप्त करें)।
• chan struct{} शुद्ध सिंक्रनाइज़ेशन के लिए एक सिग्नल चैनल के रूप में।