J'ai étudié la goroutine aujourd'hui, je vais donc la publier ici!
Goroutine est exécuté en parallèle en spécifiant une fonction dans l'instruction go!
Tout d'abord, écrivons une fonction ordinaire.
package main
import (
"fmt"
"time"
)
func goroutine(s string) {
for i := 0; i < 5; i++ {
time.Sleep(100 * time.Millisecond)
fmt.Println(s)
}
}
func hoge(s string) {
for i := 0; i < 5; i++ {
time.Sleep(100 * time.Millisecond)
fmt.Println(s)
}
}
func main() {
goroutine("world")
hoge("hello")
}
Résultat d'exécution
world
world
world
world
world
hello
hello
hello
hello
hello
C'est juste que la fonction est normalement exécutée toutes les 0,1 seconde à partir du haut.
Pour ce faire en parallèle, vous pouvez simplement préfixer le nom de la fonction avec go. ** **
(Omis parce que c'est la même chose)
func main() {
go goroutine("world")
hoge("hello")
}
Résultat d'exécution
hello
world
world
hello
world
hello
hello
world
world
hello
Puisqu'ils sont exécutés en parallèle, la sortie sera mixée. L'exécution simultanée peut être facilement réalisée en spécifiant simplement l'instruction go de cette manière.
Que se passe-t-il si vous commentez la partie horaire ici?
package main
import (
"fmt"
)
func goroutine(s string) {
for i := 0; i < 5; i++ {
//time.Sleep(100 * time.Millisecond)
fmt.Println(s)
}
}
func hoge(s string) {
for i := 0; i < 5; i++ {
//time.Sleep(100 * time.Millisecond)
fmt.Println(s)
}
}
func main() {
go goroutine("world")
hoge("hello")
}
Résultat d'exécution
hello
hello
hello
hello
hello
Quand j'ai commenté la partie temporelle, seul bonjour était sorti. En effet, même si le thread goroutine est créé par un traitement parallèle, le traitement de la fonction principale est terminé en premier. C'est parce que la fonction goroutine s'est terminée sans être exécutée.
Gardez à l'esprit que le code du programme sera terminé même si le traitement de ** gorutine n'est pas terminé de cette manière **.
Alors, que pouvons-nous faire pour éviter cela?
Utilisez ** sync.WaitGroup **.
sync.WaitGroup
package main
import (
"fmt"
"sync"
)
func goroutine(s string, wg *sync.WaitGroup) {
for i := 0; i < 5; i++ {
fmt.Println(s)
}
wg.Done()
}
func hoge(s string) {
for i := 0; i < 5; i++ {
fmt.Println(s)
}
}
func main() {
var wg sync.WaitGroup
wg.Add(1)
go goroutine("world", &wg)
hoge("hello")
wg.Wait()
}
De cette façon, déclarez une variable appelée wg et décrivez qu'il existe un processus parallèle avec` `` wg.Add (1) ``. Passez l'adresse de `` wg à la fonction goroutine comme argument.
Ensuite, en écrivant wg.Wait () '', il attendra que le processus se termine jusqu'à ce que la fonction gorutine wg.Done () '' soit appelée.
En écrivant de cette manière, vous pouvez éviter la fin du processus sans exécuter la fonction goroutine.
Au fait, wg.Add (1) '' attend que le processus de goroutine se termine, donc commenter wg.Done () '' entraînera une erreur.
wg.Après avoir ajouté wg.Done()Doit être appelé pour indiquer que le processus est terminé.
La fonction goroutine peut également être écrite comme suit.
```go
func goroutine(s string, wg *sync.WaitGroup) {
defer wg.Done()
for i := 0; i < 5; i++ {
fmt.Println(s)
}
}
Si vous utilisez l'instruction defer, wg.Done () sera exécuté après la fin du traitement de la fonction, vous pouvez donc également l'écrire comme ceci.
Si vous avez des erreurs ou des impressions, veuillez commenter! !!