Comment les fonctions Golang interagissent-elles avec les goroutines ?

Les fonctions Go interagissent avec Goroutine en transmettant des données via des canaux, un flux d'exécution de groupe d'attente ou de contrôle de canal, des tâches de mutex ou de synchronisation de canal : Transmission de données : utilisez des canaux comme files d'attente FIFO pour envoyer et recevoir des valeurs des fonctions vers les coroutines. Contrôlez le flux d'exécution : utilisez le groupe d'attente pour attendre la fin de l'exécution de la coroutine, ou utilisez le canal pour notifier à la coroutine d'effectuer des opérations spécifiques. Tâches de synchronisation : utilisez un mutex ou un canal pour synchroniser les ressources accessibles simultanément afin de garantir qu'une seule coroutine accède aux ressources à la fois.

Comment les fonctions Go interagissent-elles avec les Goroutines ?

Dans Go, les Goroutines sont des threads légers qui s'exécutent simultanément. Ils vous permettent d'exécuter du code en parallèle, améliorant ainsi les performances des applications. Les fonctions peuvent interagir avec les coroutines pour contrôler le flux d'exécution, transmettre des données et synchroniser les tâches.

Transmission de données

Les données peuvent être transmises des fonctions aux coroutines via des canaux. Un canal est une file d'attente FIFO (premier entré, premier sorti) qui permet aux coroutines de recevoir et d'envoyer des valeurs à partir de fonctions. L'exemple suivant montre comment utiliser les canaux :

package main

import "fmt"

func sendData(ch chan<- int) {
    for i := 0; i < 10; i++ {
        ch <- i
    }
    close(ch)
}

func receiveData(ch <-chan int) {
    for {
        data, ok := <-ch
        if !ok {
            return
        }
        fmt.Println("Received:", data)
    }
}

func main() {
    ch := make(chan int)
    go sendData(ch)
    receiveData(ch)
}

Contrôle du flux d'exécution

Vous pouvez utiliser un groupe d'attente ou un canal pour contrôler le flux d'exécution des coroutines. Le groupe d'attente vous permet d'attendre la fin de l'exécution de toutes les coroutines, tandis que le canal peut être utilisé pour notifier aux coroutines d'effectuer des actions spécifiques. L'exemple suivant montre comment utiliser le groupe d'attente :

package main

import (
    "fmt"
    "sync"
)

var wg sync.WaitGroup

func task(i int) {
    fmt.Println("Task", i)
    wg.Done()
}

func main() {
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go task(i)
    }
    wg.Wait()
}

Tâches de synchronisation

Les ressources accédées simultanément peuvent être synchronisées via un mutex ou un canal. Mutex mutex permet à une coroutine d'accéder aux ressources à la fois. Le canal peut être utilisé pour bloquer les coroutines jusqu'à ce que les ressources soient disponibles. L'exemple suivant montre comment utiliser mutex :

package main

import (
    "fmt"
    "sync"
)

var mutex sync.Mutex

func task(data string) {
    mutex.Lock()
    fmt.Println(data)
    mutex.Unlock()
}

func main() {
    for i := 0; i < 10; i++ {
        go task(fmt.Sprintf("Task %d", i))
    }
}

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!