Über Zukunft/Versprechen in Golang

Die folgende Tutorial-Kolumne von golang wird Ihnen die Zukunft/das Versprechen in Golang vorstellen. Ich hoffe, dass sie Freunden in Not hilfreich sein wird!

Zukunft/Versprechen in Golang

Heutzutage sind Netzwerkanfragen der häufigste Engpass bei der Anwendungsausführung. Die Netzwerkanfrage dauert nur wenige Millisekunden, das Warten auf die Antwort dauert jedoch hundertmal länger. Wenn Sie also mehrere Netzwerkanfragen ausführen, ist die parallele Ausführung aller Anfragen die beste Option, um die Latenz zu reduzieren. Zukunft/Versprechen ist eines der Mittel, um dieses Ziel zu erreichen.

Eine Zukunft bedeutet, dass Sie etwas „in der Zukunft“ benötigen (normalerweise das Ergebnis einer Netzwerkanfrage), aber Sie müssen eine solche Anfrage jetzt initiieren und diese Anfrage wird asynchron ausgeführt. Oder anders ausgedrückt: Sie müssen eine asynchrone Anfrage im Hintergrund ausführen.

Das Future/Promise-Muster verfügt über entsprechende Implementierungen in mehreren Sprachen. Beispielsweise verfügt ES2015 über Promise und Async-Await, Scala verfügt über eine integrierte Zukunft und schließlich verfügt Golang über Goroutine und Channel, um ähnliche Funktionen zu erreichen. Eine einfache Implementierung ist unten angegeben. Die Methode

//RequestFuture, http request promise.
func RequestFuture(url string) <-chan []byte {
    c := make(chan []byte, 1)
    go func() {
        var body []byte
        defer func() {
            c <- body
        }()

        res, err := http.Get(url)
        if err != nil {
            return
        }
        defer res.Body.Close()

        body, _ = ioutil.ReadAll(res.Body)
    }()

    return c
}

func main() {
  future := RequestFuture("https://api.github.com/users/octocat/orgs")
  body := <-future
  log.Printf("reponse length: %d", len(body))
}

RequestFuture gibt einen Kanal zurück. Zu diesem Zeitpunkt wird die http-Anfrage noch asynchron im Goroutine-Hintergrund ausgeführt. Die Hauptmethode kann weiterhin andere Codes ausführen, z. B. das Auslösen anderer Future usw. Wenn Ergebnisse benötigt werden, müssen wir die Ergebnisse aus dem Kanal lesen. Wenn die http-Anfrage nicht zurückgegeben wurde, wird die aktuelle Goroutine blockiert, bis das Ergebnis zurückgegeben wird. RequestFuture方法理科返回一个channel，这个时候http请求还在一个goroutine后台异步运行。main方法可以继续执行其他的代码，比如触发其他的Future等。当需要结果的时候，我们需要从channel里读取结果。如果http请求还没有返回的话就会阻塞当前的goroutine，知道结果返回。

然而，以上的方法还有一点局限。错误无法返回。在上面的例子里，如果http请求出现错误的话，body的值会是nil/empty。但是，由于channel只能返回一个值，你需要创建一个单独的struct来包装两个返回的结果。

修改以后的结果：

// RequestFutureV2 return value and error
func RequestFutureV2(url string) func() ([]byte, error) {
    var body []byte
    var err error

    c := make(chan struct{}, 1)
    go func() {
        defer close(c)

        var res *http.Response
        res, err = http.Get(url)
        if err != nil {
            return
        }

        defer res.Body.Close()
        body, err = ioutil.ReadAll(res.Body)
    }()

    return func() ([]byte, error) {
        <-c
        return body, err
    }
}

这个方法返回了两个结果，解决了第一个方法的局限性问题。使用的时候是这样的：

func main() {
    futureV2 := RequestFutureV2("https://api.github.com/users/octocat/orgs")

    // not block
    log.Printf("V2 is this locked again")

    bodyV2, err := futureV2() // block
    if err == nil {
        log.Printf("V2 response length %d\n", len(bodyV2))
    } else {
        log.Printf("V2 error is %v\n", err)
    }
}

上面的修改带来的好处就是futureV2()方法的调用可以是多次的。并且都可以返回同样的结果。

但是，如果你想用这个方法实现很多不同的异步功能，你需要写很多的额外的代码。我们可以写一个util方法来克服这个困难。

// Future boilerplate method
func Future(f func() (interface{}, error)) func() (interface{}, error) {
    var result interface{}
    var err error

    c := make(chan struct{}, 1)
    go func() {
        defer close(c)
        result, err = f()
    }()

    return func() (interface{}, error) {
        <-c
        return result, err
    }
}

调用Future方法的时候会执行房里的很多channel方面的小技巧。为了能够达到通用的目的有一个从[]buyte->interface{}->[]byteAllerdings weist die obige Methode noch einige Einschränkungen auf. Der Fehler kann nicht zurückgegeben werden. Wenn im obigen Beispiel ein Fehler in der http-Anfrage auftritt, ist der Wert von body null/leer. Da der Kanal jedoch nur einen Wert zurückgeben kann, müssen Sie eine separate Struktur erstellen, um die beiden zurückgegebenen Ergebnisse zu verpacken. Ergebnis nach der Änderung:

rrreee🎜Diese Methode gibt zwei Ergebnisse zurück und löst damit die Einschränkungen der ersten Methode. Bei Verwendung sieht es so aus: 🎜rrreee🎜Der Vorteil der obigen Modifikation besteht darin, dass die Methode futureV2() mehrmals aufgerufen werden kann. Und beide können das gleiche Ergebnis liefern. 🎜🎜Wenn Sie diese Methode jedoch zum Implementieren vieler verschiedener asynchroner Funktionen verwenden möchten, müssen Sie viel zusätzlichen Code schreiben. Wir können eine Util-Methode schreiben, um diese Schwierigkeit zu überwinden. 🎜rrreee🎜Beim Aufruf der Future-Methode werden viele Kanaltricks im Raum ausgeführt. Um universelle Zwecke zu erreichen, gibt es eine Typkonvertierung von []buyte->interface{}->[]byte. Wenn ein Fehler auftritt, wird eine Laufzeit-🎜Panik🎜 ausgelöst. 🎜🎜

Das obige ist der detaillierte Inhalt vonÜber Zukunft/Versprechen in Golang. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!