Go-Leistung: Funktionsparameter vs. globale Variablen: Gibt es einen echten Geschwindigkeitsunterschied?

Leistungsauswirkungen von Funktionsparametern im Vergleich zu globalen Variablen

Im Bereich der Go-Programmierung stellt sich häufig die Frage: Sollten Funktionsparameter priorisiert werden? über globale Variablen für optimale Leistung?

Betrachten Sie die Funktion checkFiles, die einen Ausschnitt ausgeschlossener Muster als verwendet Argument:

func checkFiles(path string, excludedPatterns []string) {
    // ...
}

Da „excludedPatterns“ während der gesamten Ausführung der Funktion konstant bleibt, schlagen einige möglicherweise vor, es zu einer globalen Variablen zu machen, um die Leistung zu optimieren, indem die wiederholte Parameterübergabe eliminiert wird.

Diese Optimierung ist jedoch unnötig in Go aufgrund der effizienten Handhabung von Slice-Parametern. Slices sind leichtgewichtige Strukturen, die Metadaten (Länge und Kapazität) enthalten und auf eine zugrunde liegende Datenstruktur verweisen. Wenn ein Slice als Funktionsparameter übergeben wird, werden nur die Metadaten kopiert, nicht das gesamte Hintergrundarray. Dies wird als „Copy-on-Write“-Semantik bezeichnet. Daher ist der Zugriff auf ausgeschlossene Muster über einen Funktionsparameter genauso effizient wie der Zugriff darauf als globale Variable.

Darüber hinaus kann die Übergabe von Parametern nach Wert häufig zu Optimierungen durch den Compiler führen, wie z. B. Caching. Globale Variablen hingegen erfordern eine komplexere Handhabung, was möglicherweise die Optimierung behindern kann.

Benchmarks zeigen, dass es keinen signifikanten Leistungsunterschied zwischen der Übergabe eines Slice als Funktionsparameter und dem Zugriff auf ein globales Slice gibt:

package main

import (
    "testing"
)

var gslice = make([]string, 1000)

func global(s string) {
    for i := 0; i < 100; i++ {
        _ = s
        _ = gslice // Access global-slice
    }
}

func param(s string, ss []string) {
    for i := 0; i < 100; i++ {
        _ = s
        _ = ss // Access parameter-slice
    }
}

func BenchmarkParameter(b *testing.B) {
    for i := 0; i < b.N; i++ {
        param("hi", gslice)
    }
}

func BenchmarkGlobal(b *testing.B) {
    for i := 0; i < b.N; i++ {
        global("hi")
    }
}

func main() {
    testing.Main(m.Run, m.init, m.cleanup, m.installFlags)
}

Benchmark-Ergebnisse deuten darauf hin, dass beide Ansätze mit nahezu identischen Geschwindigkeiten arbeiten:

BenchmarkParameter-8   20000000                80.2 ns/op
BenchmarkGlobal-8     20000000                79.9 ns/op

Zusammenfassend lässt sich sagen, dass die Ergebnisse für den betreffenden Anwendungsfall bestanden sind „excludedPatterns“ als Funktionsparameter wird empfohlen, da es den Code vereinfacht, die Lesbarkeit verbessert und eine vergleichbare Leistung wie globale Variablen in Go bietet.

Das obige ist der detaillierte Inhalt vonGo-Leistung: Funktionsparameter vs. globale Variablen: Gibt es einen echten Geschwindigkeitsunterschied?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!