Future和Promise怎么在Golang中使用

這篇文章給大家介紹Future和Promise怎么在Golang中使用，內容非常詳細，感興趣的小伙伴們可以參考借鑒，希望對大家能有所幫助。

一個Future就是說“將來”你需要某些東西（一般就是一個網絡請求的結果），但是你現在就要發起這樣的請求，并且這個請求會異步執行。或者換一個說法，你需要在后臺執行一個異步請求。

Future/Promise模式在多種語言都有對應的實現。比如ES2015就有Promise和async-await，Scala內置了Future，最后在Golang里有goroutine和channel可以實現類似的功能。下面給出一個簡單的實現。

//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方法理科返回一個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{}->[]byte的類型轉換。如果出現錯的話會引發一個運行時的panic。

關于Future和Promise怎么在Golang中使用就分享到這里了，希望以上內容可以對大家有一定的幫助，可以學到更多知識。如果覺得文章不錯，可以把它分享出去讓更多的人看到。