J'essaie de créer un canal asynchrone et je me suis penché sur http://golang.org/ref/spec#Making_slices_maps_and_channels .
c := make(chan int, 10) // channel with a buffer size of 10
Qu'est-ce que cela signifie que la taille de la mémoire tampon est 10? Qu'est-ce que la taille de la mémoire tampon représente/limite?
La taille de la mémoire tampon est le nombre d'éléments pouvant être envoyés au canal sans bloquer l'envoi. Par défaut, un canal a une taille de tampon de 0 (vous l'obtenez avec make(chan int)
). Cela signifie que chaque envoi bloquera jusqu’à ce qu’un autre groupe reçoive le canal. Un canal de taille tampon 1 peut contenir 1 élément jusqu’à l’envoi de blocs.
c := make(chan int, 1)
c <- 1 // doesn't block
c <- 2 // blocks until another goroutine receives from the channel
Le code suivant illustre le blocage du canal non mis en tampon:
// to see the diff, change 0 to 1
c := make(chan struct{}, 0)
go func() {
time.Sleep(2 * time.Second)
<-c
}()
start := time.Now()
c <- struct{}{} // block, if channel size is 0
elapsed := time.Since(start)
fmt.Printf("Elapsed: %v\n", elapsed)
Vous pouvez jouer avec le code ici .
package main
import (
"fmt"
"time"
)
func receiver(ch <-chan int) {
time.Sleep(500 * time.Millisecond)
msg := <-ch
fmt.Printf("receive messages %d from the channel\n", msg)
}
func main() {
start := time.Now()
zero_buffer_ch := make(chan int, 0)
go receiver(zero_buffer_ch)
zero_buffer_ch <- 444
elapsed := time.Since(start)
fmt.Printf("Elapsed using zero_buffer channel: %v\n", elapsed)
restart := time.Now()
non_zero_buffer_ch := make(chan int, 1)
go receiver(non_zero_buffer_ch)
non_zero_buffer_ch <- 4444
reelapsed := time.Since(restart)
fmt.Printf("Elapsed using non zero_buffer channel: %v\n", reelapsed)
}
résultat:
recevoir les messages 444 du canal
Temps écoulé via le canal zero_buffer: 505.6729ms
Écoulé via un canal autre que zero_buffer: 0s