L'affectation de pointeurs est-elle dans Go Atomic ?

Atomicité des affectations de pointeurs dans Go

L'attribution d'un pointeur dans Go est-elle atomique ? En d'autres termes, plusieurs threads peuvent-ils manipuler simultanément un pointeur sans provoquer de comportement indéfini ?

Réponse :

Les opérations atomiques dans Go sont limitées à celles explicitement définies dans la synchronisation. paquet atomique. Par conséquent, il n'est pas garanti que l'attribution d'un pointeur régulier soit atomique.

Pour garantir un comportement cohérent entre les threads, vous avez deux options :

1. Synchronisation avec des verrous :

Utilisez des primitives de synchronisation telles que sync.Mutex pour protéger l'accès au pointeur. Par exemple :

var p *int
var lock sync.Mutex

func GetPointer() *int {
    lock.Lock()
    defer lock.Unlock()
    return p
}

func SetPointer(value *int) {
    lock.Lock()
    p = value
    lock.Unlock()
}

2. Primitives atomiques (prudence conseillée) :

Vous pouvez également utiliser sync.atomic pour effectuer des affectations de pointeurs atomiques. Cependant, cette approche nécessite une gestion prudente des conversions de pointeurs non sécurisées :

import (
    "sync/atomic"
    "unsafe"
)

var p = unsafe.Pointer(nil)

func SetPointer(value *int) {
    atomic.StorePointer(&p, unsafe.Pointer(value))
}

Recommandation :

Bien que les primitives atomiques fournissent un moyen pratique d'effectuer des opérations atomiques, elles peuvent être sujet aux erreurs. L'utilisation de mutex est généralement préférée dans Go pour protéger l'accès simultané aux données partagées.

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!