Puisque Goroutine fonctionne en parallèle, les données ne peuvent pas être échangées normalement. Cependant, vous pouvez échanger des données en utilisant channel.
C'est comme connecter un tunnel!
package main
import (
"fmt"
)
func goroutine1(s []int, c chan int) {
sum := 0
for _, v := range s {
sum += v
}
//Envoyer des données au canal
c <- sum
}
func main() {
s := []int{1, 2, 3, 4}
c := make(chan int)
go goroutine1(s, c)
//Recevoir les données envoyées
p := <-c
fmt.Println(p) // => 10
}
La valeur est envoyée à c avec c <-sum et reçue avec p: = <-c. Ici, il est bloqué jusqu'à ce qu'il soit reçu, et p attend jusqu'à ce qu'il reçoive la somme. C'est similaire à sync.Wait!
Buffered channels Un tampon est une zone de mémoire pour stocker temporairement des données lorsque le traitement est effectué par un programme. Une image qui stocke des données temporaires sur un canal.
package main
import "fmt"
func main() {
//Jusqu'à 2 tampons peuvent être enregistrés
ch := make(chan int, 2)
ch <- 100
//len()Vous pouvez vérifier la longueur de la chaîne avec
fmt.Println(len(ch))
ch <- 200
fmt.Println(len(ch))
//J'obtiens une erreur lorsque j'essaye d'envoyer les troisièmes données
ch <- 300
fmt.Println(len(ch)) // => fatal error: all goroutines are asleep - deadlock!
}
Résultat d'exécution
1
2
fatal error: all goroutines are asleep - deadlock!
goroutine 1 [chan send]:
main.main()
/tmp/sandbox795806942/prog.go:11 +0x16f
Vous ne pouvez en enregistrer que deux, donc essayer d'envoyer le troisième entraînera bien sûr une erreur. (Impasse)
Si vous retirez un canal à l'avant et envoyez 300 comme indiqué dans ↓, aucune erreur ne se produira.
func main() {
ch := make(chan int, 2)
ch <- 100
fmt.Println(len(ch))
ch <- 200
fmt.Println(len(ch))
x := <-ch
fmt.Println(x)
ch <- 300
fmt.Println(len(ch))
}
Résultat d'exécution
1
2
100
2
Ensuite, regardez le code ci-dessous ↓
package main
import "fmt"
func main() {
ch := make(chan int, 2)
ch <- 100
fmt.Println(len(ch))
ch <- 200
fmt.Println(len(ch))
for c := range ch {
fmt.Println(c)
}
}
Ceci essaie de boucler le canal dans la plage, mais c'est une erreur.
Résultat d'exécution
1
2
100
200
fatal error: all goroutines are asleep - deadlock!
goroutine 1 [chan receive]:
main.main()
/tmp/sandbox892357489/prog.go:12 +0x1f3
C'est parce qu'il essaie de boucler sur un troisième canal qui n'existe pas. Pour arrêter la lecture en boucle sur le deuxième canal, vous devez fermer le canal une fois. Pour cela, il faut décrire close (ch).
package main
import "fmt"
func main() {
ch := make(chan int, 2)
ch <- 100
fmt.Println(len(ch))
ch <- 200
fmt.Println(len(ch))
close(ch)
for c := range ch {
fmt.Println(c)
}
}
Résultat d'exécution
1
2
100
200
Si vous avez des suggestions, je vous serais reconnaissant de bien vouloir commenter! !!