Go Concurrency : mutex vs canaux avec exemples

Synchronisation des compteurs en programmation concurrente Go : Mutex, canaux tamponnés et canaux non tamponnés

Lors de la création d'applications simultanées dans Go, la synchronisation est cruciale pour garantir un accès sécurisé aux données partagées. Mutex et Channel sont les principaux outils de synchronisation dans Go.

Cet article explore plusieurs façons de créer des compteurs de concurrence sécurisés. Bien que l'article de référence résolve ce problème en utilisant Mutex, nous explorerons également des alternatives utilisant des canaux avec et sans tampon.

Description du problème

Nous devons construire un compteur qui peut être utilisé simultanément en toute sécurité.

Code compteur

<code class="language-go">package main

type Counter struct {
    count int
}

func (c *Counter) Inc() {
    c.count++
}

func (c *Counter) Value() int {
    return c.count
}</code>

Pour sécuriser la concurrence de notre code, écrivons quelques tests.

1. Utiliser Mutex

Mutex (mutex) est une primitive de synchronisation qui garantit qu'une seule goroutine peut accéder aux parties critiques du code à la fois. Il fournit un mécanisme de verrouillage : lorsqu'une goroutine se verrouille Mutex, les autres goroutines essayant de la verrouiller seront bloquées jusqu'à ce que Mutex soit déverrouillée. Par conséquent, il est souvent utilisé lorsqu’une variable ou une ressource partagée doit être protégée des conditions de concurrence.

<code class="language-go">package main

import (
    "sync"
    "testing"
)

func TestCounter(t *testing.T) {
    t.Run("using mutexes and wait groups", func(t *testing.T) {
        counter := Counter{}
        wantedCount := 1000

        var wg sync.WaitGroup
        var mut sync.Mutex

        wg.Add(wantedCount)

        for i := 0; i < wantedCount; i++ {
            go func() {
                defer wg.Done()
                mut.Lock()
                counter.Inc()
                mut.Unlock()
            }()
        }

        wg.Wait()
        if counter.Value() != wantedCount {
            t.Errorf("got %d, want %d", counter.Value(), wantedCount)
        }
    })
}</code>

Le code utilise sync.WaitGroup pour suivre l'achèvement de toutes les goroutines et utilise sync.Mutex pour empêcher plusieurs goroutines d'accéder au compteur partagé en même temps.

2. Utiliser le canal tampon

Les chaînes sont un moyen pour Go de permettre aux goroutines de communiquer en toute sécurité. Ils sont capables de transférer des données entre les goroutines et d'assurer la synchronisation en contrôlant l'accès aux données transmises.

Dans cet exemple, nous utiliserons des canaux pour bloquer les goroutines et permettre à une seule goroutine d'accéder aux données partagées. Les canaux tamponnés ont une capacité fixe, ce qui signifie qu'ils peuvent contenir un nombre prédéfini d'éléments avant de bloquer l'expéditeur. L'expéditeur ne bloquera que lorsque le tampon sera plein.

<code class="language-go">package main

import (
    "sync"
    "testing"
)

func TestCounter(t *testing.T) {
    t.Run("using buffered channels and wait groups", func(t *testing.T) {
        counter := Counter{}
        wantedCount := 1000

        var wg sync.WaitGroup
        wg.Add(wantedCount)

        ch := make(chan struct{}, 1)

        ch <- struct{}{} // 允许第一个 goroutine 开始

        for i := 0; i < wantedCount; i++ {
            go func() {
                defer wg.Done()
                <-ch
                counter.Inc()
                ch <- struct{}{}
            }()
        }

        wg.Wait()
        if counter.Value() != wantedCount {
            t.Errorf("got %d, want %d", counter.Value(), wantedCount)
        }
    })
}</code>

Le code utilise un canal tamponné d'une capacité de 1, permettant à une seule goroutine d'accéder au compteur à la fois.

3. Utilisez des canaux non tamponnés

Les canaux sans tampon n'ont pas de tampon. Ils bloquent l'expéditeur jusqu'à ce que le destinataire soit prêt à recevoir des données. Cela fournit une synchronisation stricte, où les données sont transmises entre les goroutines une par une.

<code class="language-go">package main

import (
    "sync"
    "testing"
)

func TestCounter(t *testing.T) {
    t.Run("using unbuffered channels and wait groups", func(t *testing.T) {
        counter := Counter{}
        wantedCount := 1000

        var wg sync.WaitGroup
        wg.Add(wantedCount)

        ch := make(chan struct{})

        go func() {
            for i := 0; i < wantedCount; i++ {
                ch <- struct{}{}
            }
            close(ch)
        }()

        for range ch {
            counter.Inc()
            wg.Done()
        }

        if counter.Value() != wantedCount {
            t.Errorf("got %d, want %d", counter.Value(), wantedCount)
        }
    })
}
</code>

Le code utilise des canaux sans tampon pour garantir qu'une seule goroutine accède au compteur à la fois.

4. Utilisez le canal tampon au lieu de WaitGroup

Nous pouvons également utiliser des canaux tamponnés sans WaitGroup, par exemple en utilisant une boucle infinie ou un autre canal pour suivre l'achèvement de la goroutine.

Conclusion

Cet article explore différentes approches pour créer des compteurs de concurrence sécurisés dans Go. Connaître ces outils et savoir quand les utiliser est essentiel pour écrire des programmes Go simultanés efficaces et sûrs.

Ressources de référence

Cet article s'inspire du chapitre sur la synchronisation dans "Apprendre Go avec les tests".

J'espère que cet article vous sera utile !

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!