Mutex et canaux dans Go : quand les utiliser ?

Choisir entre les mutex et les canaux : quand utiliser chacun

Introduction

Lors de la synchronisation de l'accès simultané aux ressources partagées dans Go , deux options principales sont disponibles : sync.Mutex et canaux (chan). Bien que les deux puissent réaliser la synchronisation, leur adéquation dépend de scénarios spécifiques.

Mutex vs Channel

Mutex (sync.Mutex) :

• Verrouille une ressource, permettant à une seule goroutine d'y accéder à la fois temps.
• Fournit la propriété exclusive et garantit que la ressource verrouillée reste dans un état cohérent.

Canal (chan) :

• Facilite la communication entre les goroutines en transmettant des messages ou des données.
• Prend en charge l'accès simultané de plusieurs goroutines, permettant échange et synchronisation de données.

Quand utiliser un mutex

• Garder un état interne : Les mutex conviennent pour protéger variables partagées au sein d'une seule goroutine, telles que des structures internes ou des caches.
• Cache problèmes : Les mutex peuvent synchroniser l'accès aux données mises en cache, garantissant ainsi la cohérence des données et évitant les conditions de concurrence.
• Pour de meilleures performances : Les mutex peuvent être plus efficaces que les canaux dans certains scénarios où la propriété exclusive d'une ressource est essentiel.

Exemples :

• Un compteur simple utilisant un mutex pour les opérations d'incrémentation et de décrémentation synchronisées.

var count int
var m sync.Mutex

func increment() {
    m.Lock()
    defer m.Unlock()
    count++
}

• Un jeu de "ping-pong" utilisant un mutex pour passer une balle partagée entre deux goroutines.

var ball *Ball
var m sync.Mutex

func player(name string) {
    for {
        m.Lock()
        ball.hits++
        fmt.Println(name, ball.hits)
        time.Sleep(100 * time.Millisecond)
        m.Unlock()
    }
}

• Un cache simple utilisant un mutex pour synchroniser l'accès à une carte.

var cache map[string]interface{}
var m sync.Mutex

func get(key string) interface{} {
    m.Lock()
    defer m.Unlock()
    return cache[key]
}

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!