Golang-Atomersatz

Golang ist eine von Google entwickelte Programmiersprache. Sie verfügt über sehr leistungsstarke Funktionen in der gleichzeitigen Programmierung. Eine davon sind atomare Operationen, die die Korrektheit gemeinsam genutzter Ressourcen in einer Multithread-Umgebung sicherstellen. In Golang werden atomare Operationen durch das Paket sync/atomic bereitgestellt. In diesem Artikel wird die atomare Ersetzungsoperation im Detail vorgestellt.

Bevor wir den atomaren Ersatz einführen, wollen wir zunächst verstehen, was atomare Operationen sind. Wenn bei der Multithread-Programmierung mehrere Threads gleichzeitig auf eine gemeinsam genutzte Ressource zugreifen müssen, treten einige Probleme auf, wenn der Zugriff nicht koordiniert ist. Wenn beispielsweise mehrere Threads versuchen, denselben Wert gleichzeitig zu ändern, kann eine Race-Bedingung auftreten, die Programmfehler oder unvorhersehbares Verhalten verursacht.

Um dieses Problem zu lösen, können wir eine Technik namens atomare Operationen verwenden. Eine atomare Operation ist eine unteilbare Operation, die während der Ausführung nicht unterbrochen oder geändert werden kann. Dadurch werden Race-Bedingungen vermieden, die dadurch entstehen, dass mehrere Threads gleichzeitig auf gemeinsam genutzte Ressourcen zugreifen. Golang bietet einige atomare Operationsfunktionen wie AddInt32, AddInt64, CompareAndSwapInt32 usw.

Die atomaren Ersetzungsoperationsfunktionen sind SwapInt32, SwapInt64, SwapUint32, SwapUint64 und SwapPointer. Am Beispiel von SwapInt32 sieht der Funktionsprototyp wie folgt aus:

func SwapInt32(addr *int32, new int32) (old int32)

Diese Funktion empfängt einen Zeiger auf eine Variable vom Typ int32 und einen neuen int32-Wert und wird dies auch tun Versuchen Sie es Der Wert an der Speicheradresse, auf die der Zeiger zeigt, wird durch den neuen Wert ersetzt und der ursprüngliche Wert wird zurückgegeben. Wenn die Ersetzung aufgrund einer gleichzeitigen Änderung fehlschlägt, wird der ursprüngliche Wert zurückgegeben. Diese Funktion ist atomar. Selbst wenn mehrere Threads gleichzeitig SwapInt32 aufrufen, um denselben Wert zu ändern, tritt kein Problem auf.

Sehen wir uns unten ein einfaches Beispiel an. Der Zähler im Beispiel ist eine Variable vom Typ int32 und mehrere Threads versuchen gleichzeitig, seinen Wert um 1 zu erhöhen. Wenn Sie keine atomaren Ersetzungsvorgänge verwenden, müssen Sie Sperren verwenden, um sicherzustellen, dass nicht mehrere Threads gleichzeitig den Zähler ändern, was zu Leistungseinbußen führt. Bei atomaren Ersatzoperationen sind keine Sperren erforderlich. Der Code lautet wie folgt:

package main

import (
    "fmt"
    "sync/atomic"
    "time"
)

func main() {
    var counter int32
    
    for i := 1; i <= 10; i++ {
        go func() {
            for {
                oldValue := atomic.LoadInt32(&counter)
                if atomic.CompareAndSwapInt32(&counter, oldValue, oldValue+1) {
                    break
                }
                time.Sleep(time.Millisecond)
            }
        }()
    }
    
    time.Sleep(time.Second * 1)
    
    fmt.Println(counter)
}

In diesem Beispiel haben wir den Anfangswert des Zählers auf 0 gesetzt und 10 Goroutinen gestartet, um 1 hinzuzufügen. In jeder Goroutine verwenden wir eine for-Schleife, um kontinuierlich zu versuchen, den Zählerwert um 1 zu erhöhen. Die LoadInt32-Funktion wird hier verwendet, um den Zählerwert zu lesen, und die CompareAndSwapInt32-Funktion wird verwendet, um atomare Ersetzungsoperationen durchzuführen. Hier wird oldValue als Basiswert für den Vergleich verwendet. Wenn der Wert des aktuellen Zählers mit oldValue übereinstimmt, wird eine atomare Ersetzungsoperation durchgeführt. Wenn die Ersetzung erfolgreich ist, verlassen Sie die Schleife. Wenn die Ersetzung fehlschlägt, warten Sie eine Weile und versuchen Sie es erneut.

In diesem Beispiel besteht eine mögliche Race-Bedingung darin, dass mehrere Goroutinen gleichzeitig den Wert des Zählers als k lesen und dann gleichzeitig 1 dazu addieren, was dazu führt, dass der Zähler nur 1 hinzufügt. Aufgrund der Verwendung atomarer Ersetzungsoperationen funktioniert jede Goroutine jedoch nur, wenn sie versucht, den Zähler zu ändern. Andere Threads können den Zähler nicht ändern, sodass keine Race-Bedingungen auftreten. Der endgültige vom Programm ausgegebene Zählerwert sollte 10 sein, und das Ergebnis sieht im Allgemeinen so aus.

In diesem Artikel werden die Funktionen für atomare Ersetzungsoperationen in Golang vorgestellt, darunter SwapInt32, SwapInt64, SwapUint32, SwapUint64 und SwapPointer. Atomare Operationen sind ein wichtiges Mittel, um die Korrektheit gemeinsam genutzter Ressourcen in der Multithread-Programmierung sicherzustellen, und sie können Race Conditions vermeiden. Golang bietet einige atomare Operationsfunktionen zum Implementieren von Funktionen wie Spin-Locks und CAS-Operationen. Programmierer können geeignete atomare Operationsfunktionen auswählen, um Probleme bei der gleichzeitigen Programmierung zu lösen.

Das obige ist der detaillierte Inhalt vonGolang-Atomersatz. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!