Verständnis von atomaren Operationen in Go mit sync/atomic

In der konkurrierenden Programmierung ist die korrekte Verwaltung des gemeinsamen Zustands von größter Bedeutung, um Datenrennen zu vermeiden und ein vorhersagbares Verhalten zu gewährleisten. Go bietet mehrere Mechanismen zur Steuerung der Konkurrenz, darunter Mutexes, Kanäle und WaitGroups. Während Mutexes (wie sync.Mutex) eine robuste Methode zum Schutz kritischer Abschnitte bieten, können sie aufgrund des Sperrens und Entsperrens manchmal einen Overhead einführen, insbesondere bei einfachen Operationen wie dem Erhöhen eines Zählers. Hier kommen atomare Operationen ins Spiel.

Go's sync/atomic-Paket bietet niedrigstufige, primitive Operationen, die gängige Aufgaben wie das Addieren, Vergleichen-und-Tauschen oder Laden von Werten auf thread-sichere Weise ohne explizites Sperren ausführen. Diese Operationen werden typischerweise mit speziellen CPU-Instruktionen implementiert, die Atomarität garantieren, d. h. sie werden in einem einzigen, unteilbaren Schritt abgeschlossen, selbst in einer Multi-Core-Umgebung. Das macht sie für bestimmte Anwendungsfälle sehr effizient.

Warum atomare Operationen?

Betrachten Sie ein Szenario, in dem mehrere Goroutinen einen gemeinsamen Zähler erhöhen müssen. Ein naiver Ansatz könnte so aussehen:

package main

import (
	"fmt"
	"runtime"
	"sync"
	time
)

func main() {
	counter := 0
	numGoroutines := 1000
	var wg sync.WaitGroup

	wg.Add(numGoroutines)
	for i := 0; i < numGoroutines; i++ {
		go func() {
			defer wg.Done()
			for j := 0; j < 1000; j++ {
				counter++ // Datenrennen!
			}
		}()
	}

	wg.Wait()
	fmt.Println("Final Counter (potential race):", counter)
}

Der mehrfache Aufruf dieses Codes kann zu unterschiedlichen Ergebnissen führen, und der endgültige counter-Wert wird wahrscheinlich kleiner als 1.000.000 sein. Das liegt daran, dass counter++ nicht atomar ist; es umfasst drei Schritte: Lesen, Erhöhen und Schreiben. Ein Kontextwechsel kann zwischen diesen Schritten auftreten, was zu verlorenen Updates führt.

Eine Möglichkeit, dies zu beheben, ist die Verwendung eines sync.Mutex:

package main

import (
	"fmt"
	sync
)

func main() {
	counter := 0
	numGoroutines := 1000
	var wg sync.WaitGroup
	var mu sync.Mutex // Mutex zum Schutz des Zählers

	wg.Add(numGoroutines)
	for i := 0; i < numGoroutines; i++ {
		go func() {
			defer wg.Done()
			for j := 0; j < 1000; j++ {
				mu.Lock()
				counter++
				mu.Unlock()
			}
		}()
	}

	wg.Wait()
	fmt.Println("Final Counter (with mutex):", counter) // Sollte 1.000.000 sein
}

Obwohl korrekt, kann das Erwerben und Freigeben eines Mutex für jede kleine Erhöhung einen unnötigen Overhead verursachen. Für einfache arithmetische Operationen oder Wertvertauschungen bietet sync/atomic eine leistungsfähigere Alternative.

Kernatomare Operationen

Das sync/atomic-Paket bietet atomare Operationen für verschiedene Ganzzahltypen (int32, int64, uint32, uint64), Zeiger (unsafe.Pointer) und boolesche Werte (implizit durch Ganzzahlen gehandhabt). Hier sind einige der am häufigsten verwendeten Funktionen:

1. Add*-Funktionen

Diese Funktionen addieren atomar einen Delta-Wert zu einem Wert und geben den neuen Wert zurück.

• atomic.AddInt32(addr *int32, delta int32) (new int32)
• atomic.AddInt64(addr *int64, delta int64) (new int64)
• atomic.AddUint32(addr *uint32, delta uint32) (new uint32)
• atomic.AddUint64(addr *uint64, delta uint64) (new uint64)

Lassen Sie uns unser Zählerbeispiel mit atomic.AddInt64 umarbeiten:

package main

import (
	"fmt"
	sync