Gli operatori di incremento in Go atomic su x86?

Question

Ecco alcuni retroscena:
Ho bisogno di una variabile contatore condivisa tra le routine di go, utilizzate per qualcosa come un leaky-bucket. So che c'è un esempio di leaky-bucket in Effective Go, sezione concomitante, ma il numero che devo seguire può essere molto grande, e ritengo sia inefficiente usare il numero di elementi in un canale per tracciarlo. Quindi sto considerando di utilizzare una variabile condivisa tra routine diverse per tracciare il numero.

Capisco che senza una configurazione esplicita, tutte le routine di go sono mappate su un thread. Ma se assegno più di un thread al programma su un computer multi-core, gli operatori di incremento sono atomici? È lo stesso per diversi tipi di dati (int32, float32, ecc.) Su macchine diverse (x86_32, x86_64, arm)?

Per essere più concreti, cosa succede se ho in una routine e counter -= 512 in un'altra routine e le due routine si verificano in esecuzione in due thread? Devo preoccuparmi della sicurezza dei thread? Devo mettere i lucchetti sulla counter?

Answer 1

No, l'incremento non dovrebbe mai essere considerato atomico. Usa le funzioni di aggiunta atomica o un mutex.

lascia supporre:

import "sync/atomic" 
var counter = new(int32) 

Uno goroutine poteva fare atomic.AddInt32(counter, 1000) mentre un altro ha fatto atomic.AddInt32(counter, -512) senza un mutex.

Se si preferisce utilizzare un mutex:

import "sync" 
var counter int32 
var mutex sync.Mutex 

func Add(x int32) { 
    mutex.Lock() 
    defer mutex.Unlock() 
    counter += x 
}