Warum ist das Anhängen an Slices in Go threadunsicher?

Warum das Anhängen an Slices Thread-unsicher sein kann

Wenn mehrere Goroutinen gleichzeitig versuchen, Daten an ein Slice anzuhängen, kann dies zu einer Datenwettlaufbedingung führen geschehen. Dies liegt daran, dass Slices in Go nicht threadsicher sind, was bedeutet, dass mehrere Goroutinen gleichzeitig auf denselben Slice-Header zugreifen und ihn ändern können, was möglicherweise zu Datenbeschädigungen führt.

Illustration zum Datenwettlauf

Betrachten Sie den folgenden Code:

destSlice := make([]myClass, 0)

var wg sync.WaitGroup
for _, myObject := range sourceSlice {
    wg.Add(1)
    go func(closureMyObject myClass) {
        defer wg.Done()
        var tmpObj myClass
        tmpObj.AttributeName = closureMyObject.AttributeName
        destSlice = append(destSlice, tmpObj)
    }(myObject)
}
wg.Wait()

In diesem Code hängen mehrere Goroutinen gleichzeitig an das destSlice-Slice an. Dies kann zu fehlenden oder leeren Daten im resultierenden Slice führen, da Goroutinen ihre Vorgänge verschachteln und die Änderungen der anderen überschreiben können.

Datenrennen mit der Option „-race“ überprüfen

Wenn Sie den Code mit der Option „-race“ ausführen, wird für jedes erkannte Datenrennen eine Warnung generiert. Die folgende Ausgabe veranschaulicht die Datenwettlaufbedingungen im bereitgestellten Code:

==================
WARNING: DATA RACE
Read at 0x00c420074000 by goroutine 6:
  main.main.func1()
      /home/icza/gows/src/play/play.go:20 +0x69

Previous write at 0x00c420074000 by goroutine 5:
  main.main.func1()
      /home/icza/gows/src/play/play.go:20 +0x106

Goroutine 6 (running) created at:
  main.main()
      /home/icza/gows/src/play/play.go:21 +0x1cb

Goroutine 5 (running) created at:
  main.main()
      /home/icza/gows/src/play/play.go:21 +0x1cb
==================

Lösung: Verwenden eines Mutex für die Synchronisierung

Um threadsichere gleichzeitige Anhänge sicherzustellen, müssen Sie kann einen Mutex verwenden, um den destSlice-Slice-Header zu schützen. Der folgende geänderte Code demonstriert dies:

var (
    mu        = &sync.Mutex{}
    destSlice = make([]myClass, 0)
)

var wg sync.WaitGroup
for _, myObject := range sourceSlice {
    wg.Add(1)
    go func(closureMyObject myClass) {
        defer wg.Done()
        var tmpObj myClass
        tmpObj.AttributeName = closureMyObject.AttributeName
        mu.Lock()
        destSlice = append(destSlice, tmpObj)
        mu.Unlock()
    }(myObject)
}
wg.Wait()

Durch den Erwerb des Mutex vor jedem Anhängevorgang verhindern Sie, dass mehrere Goroutinen gleichzeitig den Slice-Header ändern, wodurch die Datenintegrität sichergestellt und die Datenwettlaufbedingung beseitigt wird.

Das obige ist der detaillierte Inhalt vonWarum ist das Anhängen an Slices in Go threadunsicher?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!