Goroutinen verstehen

Go zeichnet sich durch seine Fähigkeit aus, konkurrierende Anwendungen einfach und effizient zu erstellen. Eines der Features, die dies ermöglichen, sind Goroutinen, eines der mächtigsten Features der Sprache. Wenn Sie mit anderen Sprachen gearbeitet haben, sind Sie wahrscheinlich mit Threads vertraut, aber Goroutinen sind anders.

Was sind Goroutinen?

Kurz gesagt handelt es sich um Funktionen oder Methoden, die gleichzeitig mit anderen Funktionen oder Methoden ausgeführt werden. Sie sind leichter als Betriebssystem-Threads, sodass Sie Tausende von Goroutinen mit viel weniger Overhead erstellen können.

Was sind Threads und warum können Goroutinen leichter sein?

Threads sind grundsätzlich Ausführungseinheiten innerhalb eines Prozesses. Ein Prozess kann mehrere Threads haben, die sich alle denselben Speicherplatz teilen, aber über einen eigenen Ausführungsstapel verfügen, bei dem es sich im Grunde um eine Datenstruktur handelt, die Informationen über die aktiven Funktionen in einem Programm speichert. Betriebssystem-Threads werden vom Betriebssystem verwaltet und skaliert und haben außerdem eine praktische Grenze von Tausenden von Threads pro Prozess und einer festen Stapelgröße (im Allgemeinen 1 MB oder mehr pro Thread).

Goroutinen sind „grüne Threads“ oder Threads auf Benutzerebene, die von der Go-Laufzeit verwaltet werden. Die dynamische Stapelgröße beginnt bei nur 2 KB und kann je nach Bedarf erweitert oder verringert werden. Deshalb können Goroutinen leichter sein.

Was ist Wettbewerb und was ist der Unterschied zur Parallelität?

Parallelität ist die gleichzeitige Bearbeitung mehrerer Aufgaben, während Parallelität Aufgaben gleichzeitig auf mehreren Prozessoren ausführt. Etwas verwirrend, aber Sie werden es jetzt besser verstehen: Wettbewerb erfordert mehr Struktur und Organisation. Siehe das Beispiel unten:

Parallelität erfordert mehr Ausführung und tatsächlich gleichzeitige Ausführung, siehe Beispiel unten:

Was sind Kanäle?

Kanäle sind Kommunikationskanäle zwischen Goroutinen. Sie ermöglichen Goroutinen die Kommunikation und Synchronisierung ihrer Ausführung. Beispiel für die Kommunikation zwischen Goroutinen über Kanäle:

func main() {
    ch := make(chan string)

    go func() {
        ch <- "Mensagem da goroutine"
    }()

    msg := <-ch
    fmt.Println(msg)
}

Lassen Sie uns nun mit Beispielen für die Verwendung von Goroutinen abschließen:

// 1. Fazendo café e torrada ao mesmo tempo
func cafeDaManha() {
   fmt.Println("Iniciando café da manhã...") // 1º: Aparece primeiro

   go fazerCafe()    // 2º: "Começando a fazer café..."
   go fazerTorrada() // 3º: "Começando a fazer torrada..."

   // Espera 5 segundos para tudo ficar pronto
   time.Sleep(5 * time.Second)
   fmt.Println("Café da manhã pronto!") // Último: Aparece depois de 5 segundos
}

func fazerCafe() {
   fmt.Println("Começando a fazer café...")
   time.Sleep(3 * time.Second) 
   fmt.Println("Café pronto!") // 4º: Aparece após 3 segundos
}

func fazerTorrada() {
   fmt.Println("Começando a fazer torrada...")
   time.Sleep(2 * time.Second)
   fmt.Println("Torrada pronta!") // 5º: Aparece após 2 segundos
}

/* Saída:
Iniciando café da manhã...
Começando a fazer café...
Começando a fazer torrada...
Torrada pronta! (após 2 segundos)
Café pronto! (após 3 segundos)
Café da manhã pronto! (após 5 segundos)
*/

// 2. Contagem com Goroutines
func contagem() {
   go contar("A", 5) // Começa a contar imediatamente
   go contar("B", 5) // Começa a contar imediatamente

   time.Sleep(6 * time.Second)
}

func contar(nome string, até int) {
   for i := 1; i <= até; i++ {
       fmt.Printf("%s: %d\n", nome, i)
       time.Sleep(1 * time.Second)
   }
}

/* Saída (aproximada - as linhas A e B se misturam):
A: 1
B: 1
A: 2
B: 2
A: 3
B: 3
A: 4
B: 4
A: 5
B: 5
*/

// 3. Enviando mensagens simples
func mensagens() {
   canal := make(chan string)

   go func() {
       canal <- "Olá!"      // 1ª mensagem enviada
       canal <- "Tudo bem?" // 2ª mensagem enviada
       canal <- "Tchau!"    // 3ª mensagem enviada
   }()

   fmt.Println(<-canal) // 1º: Imprime "Olá!"
   fmt.Println(<-canal) // 2º: Imprime "Tudo bem?"
   fmt.Println(<-canal) // 3º: Imprime "Tchau!"
}

/* Saída:
Olá!
Tudo bem?
Tchau!
*/

Das obige ist der detaillierte Inhalt vonGoroutinen verstehen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!