Golang-Funktion und Goroutine-Lebenszyklus

Funktionslebenszyklus: Deklaration und Kompilierung: Der Compiler überprüft die Syntax und den Typ der Funktion. Ausführung: Wird ausgeführt, wenn die Funktion aufgerufen wird. Rückkehr: Rückkehr zum aufrufenden Ort nach der Ausführung. Goroutine-Lebenszyklus: Erstellung und Start: Erstellen und starten Sie über das Schlüsselwort „go“. Ausführung: Wird asynchron ausgeführt, bis die Aufgabe abgeschlossen ist. Ende: Die Aufgabe endet, wenn sie abgeschlossen ist oder ein Fehler auftritt. Aufräumen: Der Garbage Collector bereinigt den von der fertigen Goroutine belegten Speicher.

Der Lebenszyklus von Golang-Funktionen und Goroutinen

Der Lebenszyklus von Funktionen

In Golang werden Funktionen unmittelbar nach ihrer Deklaration kompiliert und der Ausführungsprozess erfolgt zur Laufzeit. Der Lebenszyklus einer Funktion ist wie folgt:

1. Deklaration und Kompilierung: Der Compiler analysiert und überprüft die Syntax und den Typ der Funktion.
2. Ausführung: Die Funktion wird nur ausgeführt, wenn der Code für den Funktionsaufruf ausgeführt wird.
3. Rückkehr: Nachdem die Funktion ausgeführt wurde, kehrt der Kontrollfluss an die Stelle zurück, an der er aufgerufen wurde.

Goroutine-Lebenszyklus

Goroutine ist ein leichter Thread in der Go-Sprache. Sein Lebenszyklus ist wie folgt:

1. Erstellung und Start: Erstellen Sie eine Goroutine über das Schlüsselwort go und starten Sie sie sofort. go 关键字创建 Goroutine 并立即启动。
2. 执行：Goroutine 异步运行，直到完成其任务。
3. 结束：当 Goroutine 完成其任务或者出现错误时，它会结束。
4. 清理：垃圾回收器会自动清理结束的 Goroutine 占用的内存。

实战案例：并行执行任务

考虑以下案例：我们想并行执行多个任务，例如计算素数的列表。

package main

import (
    "fmt"
    "sync"
    "time"
)

// 函数检查给定数字是否是素数。
func isPrime(n int) bool {
    if n <= 1 {
        return false
    }
    for i := 2; i*i <= n; i++ {
        if n%i == 0 {
            return false
        }
    }
    return true
}

func main() {
    // 创建一个等待组以等待所有 Goroutine 完成。
    var wg sync.WaitGroup

    // 创建和启动一个 Goroutine 来检查每个数字是否是素数。
    for i := 1; i <= 100; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done() // Goroutine 完成后调用 Done() 以减少等待组计数。
            if isPrime(i) {
                fmt.Println(i)
            }
        }(i)
    }

    // 等待所有 Goroutine 完成。
    wg.Wait()
}

在这个案例中：

• isPrime 函数负责检查给定的数字是否是素数。
• main 函数创建和启动一个 Goroutine 来并行检查每个数字是否是素数。
• sync.WaitGroup 用于确保在所有 Goroutine 完成之前主程序不会退出。
• defer wg.Done()

Ausführung: 🎜Goroutine läuft asynchron, bis es seine Aufgabe erledigt. 🎜🎜🎜Ende: 🎜Eine Goroutine endet, wenn sie ihre Aufgabe erledigt oder ein Fehler auftritt. 🎜🎜🎜Reinigung: 🎜Der Garbage Collector bereinigt automatisch den von der fertigen Goroutine belegten Speicher. 🎜🎜🎜Praktischer Fall: Aufgaben parallel ausführen🎜🎜Stellen Sie sich den folgenden Fall vor: Wir möchten mehrere Aufgaben parallel ausführen, beispielsweise die Berechnung einer Liste von Primzahlen. 🎜rrreee🎜In diesem Fall: Die Funktion 🎜

🎜isPrime ist dafür verantwortlich, zu prüfen, ob die angegebene Zahl eine Primzahl ist. 🎜🎜Die Funktion main erstellt und startet eine Goroutine, um zu prüfen, ob jede Zahl parallel eine Primzahl ist. 🎜🎜sync.WaitGroup wird verwendet, um sicherzustellen, dass das Hauptprogramm nicht beendet wird, bevor alle Goroutinen abgeschlossen sind. 🎜🎜defer wg.Done() Stellt sicher, dass jede Goroutine nach Abschluss die Anzahl der Wartegruppen verringert. 🎜🎜

Das obige ist der detaillierte Inhalt vonGolang-Funktion und Goroutine-Lebenszyklus. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!