Synchrone und asynchrone Implementierungsmethoden von Golang-Funktionen

Golang ist eine High-Level-Programmiersprache, die gleichzeitige Programmierung unterstützt. Sie bietet umfangreiche Mechanismen und Syntaxfunktionen für gleichzeitige Programmierung, um Entwicklern die Implementierung komplexer Multithread- oder Multi-Coroutine-Programme zu erleichtern. Unter diesen sind Synchronisation und Asynchronität zwei häufig verwendete Methoden in der gleichzeitigen Programmierung. In diesem Artikel werden die synchronen und asynchronen Implementierungsmethoden von Golang-Funktionen und ihre Verwendungsszenarien vorgestellt.

1. Implementierungsmethode der synchronen Funktion

Synchrone Funktion bedeutet, dass das Programm während der Ausführung der Funktion darauf wartet, dass die Funktion das Ergebnis zurückgibt, bevor es mit der Ausführung fortfährt nächste Operation. In Golang lauten die häufig verwendeten Implementierungsmethoden für Synchronisationsfunktionen wie folgt.

1. Blockierender Aufruf

Blockierender Aufruf ist die am häufigsten verwendete Methode zum Implementieren synchroner Funktionen, das heißt, wenn eine Funktion aufgerufen wird, blockiert das Programm immer das Warten auf Funktion, um die Ausführung abzuschließen und das Ergebnis zurückzugeben. Fahren Sie dann mit dem nächsten Schritt fort. Beispielsweise ist die f-Funktion im folgenden Code ein blockierender Aufruf:

func f() int {
    time.Sleep(time.Second * 5)
    return 42
}

func main() {
    x := f()
    fmt.Println(x)
}

Die f-Funktion im obigen Code simuliert einen zeitaufwändigen Vorgang und benötigt 5 Sekunden, um das Ergebnis zurückzugeben. Wenn die f-Funktion in der Hauptfunktion aufgerufen wird, blockiert das Programm immer und wartet darauf, dass die f-Funktion die Ausführung abschließt und das Ergebnis zurückgibt, bevor es mit dem nächsten Schritt fortfährt.

2. Multi-Thread-Synchronisation

Golang bietet einen Multi-Thread-Programmiermechanismus, der mehrere Threads verwenden kann, um Aufgaben parallel auszuführen. Wenn mehrere Threads gleichzeitig auf dieselbe Ressource zugreifen, sind Synchronisierungsvorgänge erforderlich, um Race Conditions zu vermeiden. Zu den gängigen Synchronisationsmethoden gehören Mutex-Sperren, Bedingungsvariablen, atomare Operationen usw. Das Folgende ist ein Beispielcode, der eine Mutex-Sperre verwendet, um eine Multithread-Synchronisation zu erreichen:

var count int
var mut sync.Mutex

func increment() {
    mut.Lock()
    count++
    mut.Unlock()
}

func main() {
    for i := 0; i < 1000; i++ {
        go increment()
    }
    time.Sleep(time.Second)
    fmt.Println(count)
}

Im obigen Code ist die Inkrementierungsfunktion eine Funktion, die eine Inkrementierungsoperation ausführt und mehrere Threads durchzählt Mutex-Sperre. Synchroner Betrieb von Variablen zur Vermeidung von Race-Bedingungen. Das Programm führt die Inkrementierungsfunktion 1000 Mal parallel über mehrere Threads aus und gibt schließlich den Wert von count aus.

2. Implementierungsmethode der asynchronen Funktion

Asynchrone Funktion bedeutet, dass das Programm während der Ausführung der Funktion nicht darauf wartet, dass die Funktion das Ergebnis zurückgibt, sondern direkt fortfährt um den nächsten Vorgang durchzuführen. Wenn die Funktion ausgeführt wird, wird das Ergebnis über eine Rückruffunktion oder eine Nachrichtenbenachrichtigung an das Programm übergeben. In Golang lauten die häufig verwendeten Methoden zur Implementierung asynchroner Funktionen wie folgt.

1. Coroutine

Coroutine ist ein leichter Thread in Golang, der mehrere Coroutinen gleichzeitig in einem einzigen Thread ausführen kann. Coroutinen sind sehr benutzerfreundlich und können über das Schlüsselwort go gestartet werden.

Das Folgende ist ein Beispielcode für die Verwendung von Coroutinen zum Implementieren asynchroner Funktionen:

func f() int {
    time.Sleep(time.Second * 5)
    return 42
}

func main() {
    ch := make(chan int)
    go func() {
        ch <- f()
    }()
    fmt.Println("doing other things")
    x := <-ch
    fmt.Println(x)
}

Im obigen Code wird der Kanal ch zum Implementieren asynchroner Vorgänge verwendet. Starten Sie eine Coroutine in der Hauptfunktion und übergeben Sie das Ausführungsergebnis der f-Funktion über den Kanal ch an das Hauptprogramm. Nachdem andere Vorgänge im Hauptprogramm ausgeführt wurden, wird das Ausführungsergebnis der f-Funktion über den Kanal empfangen, um den asynchronen Vorgang abzuschließen.

2. Rückruffunktion

Die Rückruffunktion bezieht sich auf die Übergabe des Ergebnisses an das Programm durch Aufrufen einer vorregistrierten Rückruffunktion, nachdem die asynchrone Funktion ausgeführt wurde. Das Folgende ist ein Beispielcode, der Rückruffunktionen verwendet, um asynchrone Funktionen zu implementieren:

func f(callback func(int)) {
    time.Sleep(time.Second * 5)
    callback(42)
}

func main() {
    f(func(x int) {
        fmt.Println(x)
    })
    fmt.Println("doing other things")
}

Im obigen Code verwendet die f-Funktion Rückruffunktionen, um asynchrone Vorgänge zu implementieren. Durch Aufrufen der vorregistrierten Rückruffunktion wird das Ergebnis der f-Funktionsausführung an das Programm übergeben. Nachdem andere Vorgänge im Hauptprogramm ausgeführt wurden, wird das Ausführungsergebnis der f-Funktion ausgegeben.

3. Synchrone und asynchrone Nutzungsszenarien

Synchronisierte und asynchrone Funktionen haben jeweils ihre eigenen Vor- und Nachteile und sollten entsprechend den spezifischen Geschäftsanforderungen ausgewählt werden.

Wenn Sie lediglich das Ausführungsergebnis einer bestimmten Funktion erhalten müssen, z. B. einer HTTP-Anforderungsoperation usw., werden häufig synchrone Funktionen verwendet. Wenn Sie zeitaufwändige Vorgänge ausführen oder mehrere Aufgaben gleichzeitig ausführen müssen, sind asynchrone Funktionen besser geeignet. Beim Herunterladen großer Dateien können Sie beispielsweise asynchrone Funktionen verwenden, um gleichzeitige Downloads zu implementieren und die Download-Geschwindigkeit zu erhöhen. Bei der Verarbeitung von Netzwerkanforderungen können Sie asynchrone Funktionen verwenden, um Anforderungen zu verarbeiten und die Wartezeit zu verkürzen.

Kurz gesagt, synchrone und asynchrone Funktionen haben in verschiedenen Szenarien bessere Nutzungseffekte, und wir müssen eine Auswahl basierend auf der tatsächlichen Situation treffen.

Das obige ist der detaillierte Inhalt vonSynchrone und asynchrone Implementierungsmethoden von Golang-Funktionen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!