Comment assurer la sécurité des threads dans Go : mutex, atomes ou canaux ?

Comment implémenter la sécurité des threads pour les variables dans Go

En Java, le concept de variables synchronisées garantit qu'un seul thread peut s'exécuter un bloc de code spécifique à un moment donné. Cependant, Go ne propose pas de mot-clé synchronisé explicite.

Justification

Go promeut une approche différente de la synchronisation des threads, guidée par le principe : « Ne communiquez pas en partageant mémoire ; partagez plutôt la mémoire en communiquant." Cela signifie éviter l'accès direct à la mémoire partagée et opter pour des mécanismes basés sur la communication comme les canaux.

Synchronisation basée sur mutex

Si vous rencontrez un scénario où un mutex est nécessaire , voici comment l'implémenter dans Allez :

var (
    mu        sync.Mutex
    protectMe int
)

func getMe() int {
    mu.Lock()
    me := protectMe
    mu.Unlock()
    return me
}

func setMe(me int) {
    mu.Lock()
    protectMe = me
    mu.Unlock()
}

Améliorations

• Convertissez sync.Mutex en sync.RWMutex pour activer l'accès en lecture simultané.
• Envisagez d'utiliser le report pour éviter les fuites de ressources en cas d'erreurs.
• Intégrez le mutex dans la valeur protégée pour améliorer lisibilité et commodité du code.

Synchronisation atomique

Si vous devez protéger une seule valeur, envisagez d'utiliser le package sync/atomic :

var protectMe int32

func getMe() int32 {
    return atomic.LoadInt32(&protectMe)
}

func setMe(me int32) {
    atomic.StoreInt32(&protectMe, me)
}

Approche basée sur la communication

Go encourage l'utilisation des canaux pour communication inter-goroutine, éliminant le besoin de variables partagées. Par exemple, dans un modèle éditeur-abonné :

type topic struct {
    subscribing []chan int
}

var t = &topic{}

func subscribe() chan int {
    ch := make(chan int)
    t.subscribing = append(t.subscribing, ch)
    return ch
}

func publish(v int) {
    for _, ch := range t.subscribing {
        ch <- v
    }
}

Cette approche garantit une communication thread-safe sans partager de mémoire.

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!