Création et gestion de goroutine dans les fonctions Golang

En langage Go, créez une goroutine à l'aide du mot-clé go et de l'appel de fonction. Lors de la gestion de goroutine, utilisez sync.WaitGroup pour la synchronisation ; utilisez le package de contexte pour annuler goroutine. En combat réel, il peut être utilisé pour traiter en parallèle les requêtes réseau, le traitement d’images et d’autres tâches.

Création et gestion de goroutines dans les fonctions Golang

Goroutine (coroutine) est une unité d'exécution parallèle légère dans le langage Go qui peut exécuter plusieurs tâches simultanément dans un seul thread.

Créer une Goroutine

Créer une goroutine est très simple Vous pouvez utiliser le mot clé go suivi d'un appel de fonction : go 关键字后跟一个函数调用即可：

func hello() {
    fmt.Println("Hello from goroutine")
}

func main() {
    go hello() // 创建一个执行 hello() 函数的 goroutine
}

Goroutine 管理

同步

在处理共享资源时，需要对 goroutine 进行同步。使用 sync.WaitGroup 可以等待一组 goroutine 完成：

var wg sync.WaitGroup

func hello(name string) {
    wg.Add(1)
    defer wg.Done()

    fmt.Println("Hello", name)
}

func main() {
    wg.Add(3)
    go hello("John")
    go hello("Mary")
    go hello("Bob")
    wg.Wait() // 等待所有 goroutine 完成
}

取消

可以使用 context

import (
    "context"
    "fmt"
    "time"
)

func heavyComputation(ctx context.Context) {
    for {
        select {
        case <-ctx.Done():
            fmt.Println("Computation cancelled")
            return
        default:
            // 执行计算
        }
    }
}

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
    defer cancel()

    go heavyComputation(ctx)
    time.Sleep(10 * time.Second) // 10 秒后取消计算
}

Gestion des goroutines

Synchronisation

Traitement partagé. resources Quand , goroutine doit être synchronisé. Utilisez sync.WaitGroup pour attendre la fin d'un groupe de goroutines :

func main() {
    urls := []string{"https://example.com", "https://example.net", "https://example.org"}

    var wg sync.WaitGroup

    for _, url := range urls {
        wg.Add(1)
        go func(url string) {
            resp, err := http.Get(url)
            if err != nil {
                log.Fatal(err)
            }

            resp.Body.Close()
            wg.Done()
        }(url)
    }

    wg.Wait()
}

Annuler

Vous pouvez utiliser le package context pour annuler les goroutines :

func main() {
    images := []string{"image1.jpg", "image2.jpg", "image3.jpg"}

    var wg sync.WaitGroup

    for _, image := range images {
        wg.Add(1)
        go func(image string) {
            img, err := image.Decode(image)
            if err != nil {
                log.Fatal(err)
            }

            // 处理图像

            wg.Done()
        }(image)
    }

    wg.Wait()
}

Cas pratique

Traitement parallèle des requêtes réseau :

🎜rrreee🎜🎜Traitement parallèle du traitement d'images : 🎜🎜rrreee

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!