Comment la fonction golang contrôle-t-elle l'exécution de goroutine ?

La fonction Go contrôle l'exécution de Goroutine des manières suivantes : runtime.Goexit() : termine de force le Goroutine actuel. sync.WaitGroup : attendez la fin d'un groupe de Goroutines. select{} : permet à un Goroutine d'attendre l'un des multiples événements et d'effectuer l'action correspondante en fonction du premier événement déclenché. context.Context : peut être utilisé pour dépasser les délais ou annuler les demandes adressées aux Goroutines.

Comment les fonctions Go contrôlent l'exécution de Goroutine

Le langage de programmation Go prend en charge la concurrence et utilise Goroutine (threads légers) pour obtenir la concurrence. Les goroutines peuvent être créées via des fonctions et démarrées à tout moment après la création. Cet article présentera les différentes fonctions utilisées pour contrôler l'exécution de Goroutine et fournira quelques exemples pratiques.

Fonction qui contrôle l'exécution de Goroutine

• runtime.Goexit() : Terminez de force le Goroutine actuel.
• sync.WaitGroup : Attendez qu'un groupe de Goroutines se termine.
• select{} : Permet à une Goroutine d'attendre l'un des multiples événements et d'effectuer l'action correspondante en fonction du premier événement déclenché.
• context.Context: peut être utilisé pour transmettre des délais ou des demandes d'annulation aux Goroutines.

Cas pratique

1. Terminez Goroutine

package main

import (
    "fmt"
    "runtime"
    "time"
)

func main() {
    go func() {
        for {
            fmt.Println("Goroutine is running...")
            time.Sleep(1 * time.Second)
        }
    }()

    // 等待 10 秒后终止 Goroutine
    time.Sleep(10 * time.Second)
    runtime.Goexit()
}

2. Utilisez sync.WaitGroup pour attendre Goroutine

package main

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

func main() {
    var wg sync.WaitGroup

    // 创建 5 个 Goroutine
    for i := 0; i < 5; i++ {
        wg.Add(1)
        go func(i int) {
            fmt.Printf("Goroutine %d is running...\n", i)
            time.Sleep(1 * time.Second)
            wg.Done()
        }(i)
    }

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

3.

package main

import (
    "fmt"
    "time"
)

func main() {
    fmt.Println("Waiting for events...")

    // 创建两个 channel
    ch1 := make(chan string)
    ch2 := make(chan string)

    // 创建两个 Goroutine 向 channel 发送数据
    go func() {
        time.Sleep(1 * time.Second)
        ch1 <- "Event from Channel 1"
    }()
    go func() {
        time.Sleep(2 * time.Second)
        ch2 <- "Event from Channel 2"
    }()

    for {
        select {
            case msg := <-ch1:
                fmt.Println(msg)
                return
            case msg := <-ch2:
                fmt.Println(msg)
                return
        }
    }
}