Fonction Golang et cycle de vie des goroutines

Cycle de vie de la fonction : déclaration et compilation : le compilateur vérifie la syntaxe et le type de la fonction. Exécution : exécuté lorsque la fonction est appelée. Retour : retour à l'emplacement appelant après l'exécution. Cycle de vie de Goroutine : Création et démarrage : Créez et démarrez via le mot-clé go. Exécution : s'exécute de manière asynchrone jusqu'à ce que la tâche soit terminée. Fin : La tâche se termine lorsqu'elle est terminée ou qu'une erreur se produit. Nettoyage : Le garbage collector nettoie la mémoire occupée par le Goroutine terminé.

Le cycle de vie des fonctions Golang et des Goroutines

Le cycle de vie des fonctions

Dans Golang, les fonctions sont compilées immédiatement après leur déclaration et le processus d'exécution a lieu au moment de l'exécution. Le cycle de vie d'une fonction est le suivant :

1. Déclaration et compilation : Le compilateur analyse et vérifie la syntaxe et le type de la fonction.
2. Exécution : La fonction ne sera exécutée que lorsque le code sera exécuté lors de l'appel de fonction.
3. Retour : Une fois la fonction exécutée, le flux de contrôle revient à l'emplacement où il a été appelé.

Cycle de vie de Goroutine

Goroutine est un fil de discussion léger en langage Go. Son cycle de vie est le suivant :

1. Création et démarrage : Créez une Goroutine grâce au mot clé go et démarrez-la immédiatement. 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()

Exécution : 🎜Goroutine s'exécute de manière asynchrone jusqu'à ce qu'il termine sa tâche. 🎜🎜🎜Fin : 🎜Une Goroutine se termine lorsqu'elle termine sa tâche ou qu'une erreur survient. 🎜🎜🎜Nettoyage : 🎜Le ramasse-miettes nettoiera automatiquement la mémoire occupée par la Goroutine terminée. 🎜🎜🎜Cas pratique : Exécuter des tâches en parallèle🎜🎜Considérons le cas suivant : Nous souhaitons exécuter plusieurs tâches en parallèle, comme calculer une liste de nombres premiers. 🎜rrreee🎜Dans ce cas : 🎜

🎜La fonction isPrime est chargée de vérifier si le nombre donné est premier. 🎜🎜La fonction main crée et démarre une Goroutine pour vérifier si chaque nombre est premier en parallèle. 🎜🎜sync.WaitGroup est utilisé pour garantir que le programme principal ne se termine pas avant que toutes les Goroutines ne soient terminées. 🎜🎜defer wg.Done() Garantit que chaque Goroutine décrémente le nombre de groupes d'attente une fois terminé. 🎜🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!