Analyse de document en langage Go : la fonction sync.Cond implémente des variables de condition

Dans le langage Go, le package sync fournit une fonction outil très pratique - sync.Cond. Cet article fournit une analyse détaillée de cette fonction et fournit un exemple de code spécifique pour aider les lecteurs à mieux comprendre et appliquer cette fonction.

1. Qu'est-ce que la fonction sync.Cond ?

En langage Go, la fonction sync.Cond est utilisée pour implémenter des variables de condition. Les variables de condition sont un mécanisme de synchronisation courant dans la programmation multithread, utilisé pour réaliser une coopération entre les threads lorsqu'un ou plusieurs threads doivent attendre qu'un événement se produise. Plus précisément, lorsqu'une certaine condition n'est pas remplie, le thread peut entrer en état de veille en attendant la variable de condition, et lorsque la variable de condition est remplie, d'autres threads peuvent coopérer en réveillant le thread en attente dans la variable de condition. La définition de la fonction

sync.Cond est la suivante :

type Cond struct {
    // contains filtered or unexported fields
}

sync.Cond est un type structure, qui ne peut pas être initialisé directement car il contient des champs non exportés. Lors de son utilisation, nous devons utiliser la fonction sync.NewCond pour l'initialisation. L'utilisation spécifique est la suivante :

func NewCond(l Locker) *Cond

Parmi eux, l est un verrou mutex utilisé pour réaliser la synchronisation entre les threads. Après l'appel d'initialisation, nous devons utiliser les trois méthodes principales de Cond - Wait, Signal et Broadcast - pour parvenir à une coopération entre les threads.

2. La méthode principale de la méthode sync.Cond

1. Wait

Wait est utilisée pour faire attendre le thread actuel pour la variable de condition. Plus précisément, lorsqu'une certaine condition n'est pas remplie, le thread peut entrer en état de veille en attendant la variable de condition et en attendant que les autres threads se réveillent.

La définition de cette méthode est la suivante :

func (c *Cond) Wait()

Lors de l'utilisation de la méthode Wait, nous devons d'abord acquérir le verrou mutex, libérer le verrou avant d'entrer dans l'état d'attente et réacquérir le verrou après avoir attendu que les autres threads se réveillent. .

L'exemple de code est le suivant :

package main

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

var (
    wg      sync.WaitGroup
    locker  sync.Mutex
    condVar *sync.Cond
)

func main() {
    condVar = sync.NewCond(&locker)
    wg.Add(2)

    // 等待条件变量
    go func() {
        defer wg.Done()
        fmt.Println("wait for cond")
        condVar.L.Lock()
        condVar.Wait()
        fmt.Println("receive signal")
        condVar.L.Unlock()
    }()

    // 发送信号
    go func() {
        defer wg.Done()
        time.Sleep(2 * time.Second)
        condVar.L.Lock()
        condVar.Signal()
        fmt.Println("send signal")
        condVar.L.Unlock()
    }()

    wg.Wait()
}

Dans le code ci-dessus, nous utilisons d'abord la fonction sync.NewCond pour initialiser un verrou mutex et sa variable de condition correspondante condVar. Ensuite, nous utilisons deux goroutines simultanées pour attendre la variable de condition et envoyer le signal respectivement. La goroutine en attente de la variable de condition acquiert d'abord le verrou mutex et libère le verrou avant d'entrer dans l'état d'attente. Après avoir attendu l'envoi du signal, la goroutine réacquiert le verrou et génère les informations d'invite pertinentes. Le processus Go qui envoie le signal acquiert le verrou mutex après avoir attendu deux secondes et libère le verrou après avoir envoyé un signal à la variable de condition.

En exécutant le code ci-dessus, nous pouvons voir que le programme affiche le contenu suivant :

wait for cond
send signal
receive signal

On peut voir que la Goroutine en attente de la variable de condition entre en état de veille via la méthode condVar.Wait après avoir attendu un certain temps . Une fois que le Goroutine émetteur du signal a envoyé le signal, le Goroutine en attente de la variable de condition est réveillé via la méthode condVar.Signal et les informations d'invite correspondantes sont renvoyées. La méthode

2. Signal

Signal est utilisée pour réveiller un thread en attente d'une variable de condition. Plus précisément, lorsqu'une certaine variable de condition change, le thread peut réveiller l'un des threads en attente de la variable de condition via la méthode Signal pour réaliser une coopération entre les threads.

La définition de cette méthode est la suivante :

func (c *Cond) Signal()

Il est à noter que la méthode Signal ne peut réveiller qu'un thread en attente d'une variable de condition. Si nous voulons réveiller plusieurs threads, nous pouvons utiliser la méthode Broadcast.

L'exemple de code est le suivant :

package main

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

var (
    wg      sync.WaitGroup
    locker  sync.Mutex
    condVar *sync.Cond
)

func main() {
    condVar = sync.NewCond(&locker)
    wg.Add(3)

    // 等待条件变量
    go func() {
        defer wg.Done()
        fmt.Println("wait for cond")
        condVar.L.Lock()
        condVar.Wait()
        fmt.Println("receive signal 1")
        condVar.L.Unlock()
    }()

    // 尝试多次等待
    go func() {
        defer wg.Done()
        for i := 0; i < 4; i++ {
            fmt.Printf("wait for cond %d
", i+1)
            condVar.L.Lock()
            condVar.Wait()
            fmt.Printf("receive signal %d
", i+1)
            condVar.L.Unlock()
        }
    }()

    // 发送信号
    go func() {
        defer wg.Done()
        time.Sleep(2 * time.Second)
        condVar.L.Lock()
        condVar.Signal()
        fmt.Println("send signal")
        condVar.L.Unlock()
        time.Sleep(2 * time.Second)
        condVar.L.Lock()
        condVar.Broadcast()
        fmt.Println("broadcast signal")
        condVar.L.Unlock()
    }()

    wg.Wait()
}

Dans le code ci-dessus, nous utilisons trois goroutines simultanées pour attendre les variables de condition et envoyer des signaux respectivement. L'une des goroutines utilise la méthode Wait pour attendre la variable de condition, tandis que l'autre goroutine essaie d'attendre plusieurs fois jusqu'à ce que le signal soit reçu. La troisième goroutine envoie d'abord un signal après avoir attendu deux secondes, puis attend deux secondes, puis envoie à nouveau un signal de diffusion.

En exécutant le code ci-dessus, nous pouvons voir que le programme affiche le contenu suivant :

wait for cond
wait for cond 1
wait for cond 2
wait for cond 3
send signal
receive signal 1
wait for cond 4
broadcast signal
receive signal 2
receive signal 3
receive signal 4

On peut voir que la Goroutine en attente de la variable de condition est d'abord réveillée et les informations d'invite correspondantes sont renvoyées. La goroutine qui a ensuite essayé d'attendre plusieurs fois a attendu et a reçu le signal respectivement. Enfin, après l'envoi du signal de diffusion, tous les Goroutines en attente de la variable de condition sont réveillés et les informations d'invite correspondantes sont renvoyées.

3. Résumé

Cet article présente brièvement la définition et les principales méthodes de la fonction sync.Cond dans le langage Go, fournit une analyse détaillée de son utilisation réelle et donne un exemple de code spécifique. Lors de la programmation multithread, il est nécessaire d’utiliser les variables de condition de manière rationnelle. Par conséquent, maîtriser l’utilisation de la fonction sync.Cond est d’une grande aide pour améliorer la sécurité et la fiabilité du code.

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!