சேனல்கள்: தட்டச்சு செய்யப்பட்ட தொடர்பு

சேனல்கள் என்பது இடையேயான தகவல்தொடர்புக்கான idiomatic பொறிமுறையாகும் goroutines. கோ தத்துவம் (ராப் பைக்):

"நினைவகத்தைப் பகிர்வதன் மூலம் தொடர்பு கொள்ளாதீர்கள்; தொடர்புகொள்வதன் மூலம் நினைவகத்தைப் பகிர்ந்து கொள்ளுங்கள்."

சேனல் என்பது ** தட்டச்சு செய்யப்பட்ட FIFO வரிசை**, வகை-பாதுகாப்பானது மற்றும் ஒரே நேரத்தில் பாதுகாப்பானது பயன்படுத்த. go உடன் இணைந்து, இது 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 இரண்டிற்கும் அனுப்பப்படலாம் (மறைமுகமான மாற்றம்). அது தெளிவை மேம்படுத்துகிறது மற்றும் தவறுகளைத் தடுக்கிறது.

பொதுவான வடிவங்கள் (முன்னோட்டம்)

• பணியாளர் குளம்: N goroutines 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 // ?

மறுபரிசீலனை

• சேனல் = தட்டச்சு செய்த FIFO வரிசை, goroutines இடையே பாதுகாப்பானது.
• தடைசெய்யப்படாதது: சந்திப்பு (அனுப்புபவர் மற்றும் பெறுநர் ஒத்திசைவு).
• இடையகப்படுத்தப்பட்டது: துண்டித்தல், முழு/காலியாக இருக்கும்போது மட்டும் தடுக்கிறது.
• close(ch): அனுப்புபவர் மட்டும்; for range மூடும் வரை பயன்படுத்துகிறது.
• திசை: chan<- T (அனுப்புவதற்கு மட்டும்), <-chan T (பெறுவதற்கு மட்டும்).
• chan struct{} தூய ஒத்திசைவுக்கான சமிக்ஞை சேனலாக.