Techniques de communication et de synchronisation inter-processus Goroutine pour les fonctions Golang

Dans Golang, goroutine est un thread léger doté de puissantes capacités de traitement simultané. La fonction est la structure de programmation de base de Golang. Elle est largement utilisée dans le développement et constitue également un outil important pour la communication et la synchronisation entre les goroutines. Cet article présentera quelques techniques de communication et de synchronisation inter-processus goroutines pour les fonctions Golang afin d'aider les développeurs Golang à mieux appliquer ces technologies.

1. Channel

Channel est l'un des outils de base de la programmation simultanée Golang. Il peut être utilisé pour la communication et la synchronisation entre les goroutines. Un canal est créé par make et a un type et une capacité. La capacité d'un canal indique la quantité de données qu'il peut mettre en mémoire tampon. Si la capacité est de 0, cela signifie qu'il s'agit d'un canal sans mise en mémoire tampon et qu'il ne peut être utilisé qu'à des fins de synchronisation.

L'utilisation des canaux Golang est très simple, il suffit d'utiliser l'opérateur <- pour envoyer et recevoir des messages. Par exemple :

ch := make(chan int, 10) // 创建具有10个缓冲区的通道

go func(ch chan int) {
    for i := 0; i < 10; i++ {
        ch <- i
    }
    close(ch) // 关闭通道
}(ch)

for value := range ch {
    fmt.Println(value)
}

Le code ci-dessus crée un canal avec 10 tampons, puis démarre une goroutine pour envoyer les valeurs de 0 à 9 au canal, et ferme le canal après l'envoi. Utilisez ensuite range pour parcourir le canal et lire en continu les données jusqu'à ce que le canal soit fermé.

2. Verrouillage mutex (mutex)

Dans Golang, une variable peut être accédée par plusieurs goroutines en même temps, provoquant une condition de concurrence. Pour éviter cela, nous devons utiliser un mutex pour protéger les variables partagées. Mutex est un mécanisme de synchronisation dans Golang, qui peut être utilisé pour garantir qu'une seule goroutine puisse accéder aux ressources partagées à tout moment.

Le verrou mutex de Golang est implémenté dans le package de synchronisation, et son utilisation est également très simple. Il vous suffit d'appeler les méthodes Lock() et Unlock(). Par exemple :

var counter int
var mutex sync.Mutex

func main() {
    for i := 0; i < 10; i++ {
        go func() {
            for j := 0; j < 100; j++ {
                mutex.Lock() // 加锁
                counter++
                mutex.Unlock() // 解锁
            }
        }()
    }

    time.Sleep(time.Second)
    fmt.Println(counter)
}

Le code ci-dessus démarre 10 goroutines, et chaque goroutine effectuera 100 opérations counter++. Utilisez un mutex pour protéger la variable du compteur afin de garantir qu'un seul goroutine peut la modifier à la fois. Utilisez la fonction time.Sleep pour attendre que toutes les goroutines terminent leur exécution et enfin imprimer la valeur du compteur.

3. Variable de condition (cond)

La variable de condition est un mécanisme de synchronisation dans Golang. Elle est utilisée avec les verrous mutex et peut être utilisée pour attendre que certains événements se produisent. , ou attend la disponibilité d'une ressource. Les variables de condition peuvent être utilisées pour coordonner les opérations de synchronisation entre plusieurs goroutines, ce qui permet aux goroutines d'attendre qu'une certaine condition soit vraie avant de poursuivre l'exécution.

Les variables de condition de Golang sont implémentées dans le package de synchronisation, et leur utilisation est également très simple. Il vous suffit d'appeler les méthodes Wait(), Signal() et Broadcast(). Par exemple :

var (
    mutex sync.Mutex
    cond  *sync.Cond
)

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

func consumer(ch <-chan int) {
    for {
        mutex.Lock()
        if len(ch) == 0 {
            cond.Wait() // 等待条件变量
        }
        value := <-ch
        fmt.Println(value)
        mutex.Unlock()
    }
}

func main() {
    ch := make(chan int, 5)

    mutex.Lock()
    cond = sync.NewCond(&mutex)
    go producer(ch)
    go consumer(ch)
    mutex.Unlock()

    time.Sleep(time.Second)
    mutex.Lock()
    cond.Signal() // 唤醒一个等待的goroutine
    mutex.Unlock()
}

Le code ci-dessus crée un canal avec un tampon, puis démarre une goroutine productrice et une goroutine consommatrice. La goroutine consommateur lit à chaque fois une valeur du canal et la génère. Si le canal est vide, la goroutine du consommateur appellera la méthode Wait() de la variable de condition puis attendra d'être réveillée. La goroutine productrice écrira en continu des données sur le canal lorsque les données seront écrites, elle appellera la méthode Signal() de la variable de condition pour réveiller la goroutine en attente.

Résumé

Dans Golang, la fonction est une structure de programmation importante, qui peut être utilisée pour la communication et la synchronisation entre les goroutines. Les canaux, les mutex et les variables de condition sont des fonctions Golang couramment utilisées pour les techniques de communication et de synchronisation inter-processus des goroutines. Ils fournissent un mécanisme de concurrence riche qui peut nous aider à mieux gérer le comportement des goroutines. Dans le même temps, nous devons également prêter attention aux problèmes liés à la programmation concurrente, tels que les conditions de concurrence, les blocages, etc., pour garantir l'exactitude et l'efficacité du programme.

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!