[Golang] Go Sprachgrundlagen Was ist Goroutine?

Ich habe heute Goroutine studiert, also werde ich es hier ausgeben!

Was ist Goroutine?

Goroutine wird parallel ausgeführt, indem eine Funktion in der go-Anweisung angegeben wird!

Schreiben wir zunächst eine gewöhnliche Funktion.

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")
}

Ausführungsergebnis
world
world
world
world
world
hello
hello
hello
hello
hello

Dies ist nur so, dass die Funktion normalerweise alle 0,1 Sekunden von oben ausgeführt wird.

Dazu können Sie dem Funktionsnamen einfach go voranstellen. ** ** **

(Ausgelassen, weil es das gleiche ist)

func main() {
	go goroutine("world")
	hoge("hello")
}

Ausführungsergebnis
hello
world
world
hello
world
hello
hello
world
world
hello

Da sie parallel ausgeführt werden, wird die Ausgabe gemischt. Die gleichzeitige Ausführung kann einfach erreicht werden, indem die go-Anweisung auf diese Weise angegeben wird.

Was passiert, wenn Sie den Zeitteil hier auskommentieren?

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")
}

Ausführungsergebnis
hello
hello
hello
hello
hello

Als ich den Zeitteil auskommentierte, wurde nur Hallo ausgegeben. Dies liegt daran, dass selbst wenn der Goroutine-Thread durch Parallelverarbeitung erstellt wird, die Verarbeitung der Hauptfunktion zuerst abgeschlossen ist. Dies liegt daran, dass die Goroutine-Funktion beendet wurde, ohne ausgeführt zu werden.

Beachten Sie, dass der Code des Programms auch dann beendet wird, wenn die Verarbeitung von ** Gorutine auf diese Weise nicht abgeschlossen ist **.

Was können wir also tun, um dies zu vermeiden?

Verwenden Sie ** 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()
}

Deklarieren Sie auf diese Weise eine Variable namens "wg" und beschreiben Sie, dass es einen parallelen Prozess mit "wg.Add (1)" gibt Übergeben Sie die Adresse von `` `wg``` als Argument an die Goroutine-Funktion.

Dann wird durch Schreiben von `wg.Wait ()` gewartet, bis der Prozess beendet ist, bis die Gorutine-Funktion `wg.Done ()` aufgerufen wird. Wenn Sie auf diese Weise schreiben, können Sie vermeiden, dass der Prozess endet, ohne die Goroutine-Funktion auszuführen.

Übrigens wartet `wg.Add (1)` darauf, dass der Goroutine-Prozess abgeschlossen ist. Wenn Sie also `` wg.Done () `auskommentieren, wird ein Fehler angezeigt.

wg.Nach dem Hinzufügen von wg.Done()Sollte aufgerufen werden, um anzuzeigen, dass der Vorgang abgeschlossen ist.

 Die Goroutine-Funktion kann auch wie folgt geschrieben werden.

```go

func goroutine(s string, wg *sync.WaitGroup) {
	defer wg.Done()
	for i := 0; i < 5; i++ {
		fmt.Println(s)
	}
}

Wenn Sie die defer-Anweisung verwenden, wird wg.Done () ausgeführt, nachdem die Funktion die Verarbeitung abgeschlossen hat, sodass Sie sie auch so schreiben können.

Vielen Dank für das Lesen bis zum Ende!

Wenn Sie Fehler oder Eindrücke haben, kommentieren Sie bitte! !!