优化 API 请求的循环方法

本篇文章给大家分享《优化 API 请求的循环方法》，覆盖了Golang的常见基础知识，其实一个语言的全部知识点一篇文章是不可能说完的，但希望通过这些问题，让读者对自己的掌握程度有一定的认识(B 数)，从而弥补自己的不足，更好的掌握它。

我的 go 代码中有一个 for 循环。每次迭代都会向某个 api 发出请求，然后将其结果保存在映射中。如何优化性能以便异步调用迭代？

我目前正在深入研究 goroutine 和通道以及所有这些，但在实际应用中我仍然遇到困难:)

results := map[string]Result

for ID, person := range people {
    result := someApiCall(person)
    results[ID] = result
}

// And do something with all the results once completed

解决方案

有很多方法可以使每次迭代异步执行。其中之一是利用 goroutine 和通道（就像您想要的那样）。

请看下面的示例。我认为如果我将解释作为注释放在代码的每个部分中会更容易。

// prepare the channel for data transporation purpose between goroutines and main routine
reschan := make(chan []interface{})

for id, person := range people {

    // dispatch an iife as goroutine, so no need to change the `someapicall()`
    go func(id string, person person) {
        result := someapicall(person)

        // send both id and result to channel.
        // it'll be better if we construct new type based id and result, but in this example i'll use channel with []interface{} type
        reschan <- []interface{}{id, result}
    }(id, person)
}

// close the channel since every data is sent.
close(reschan)

// prepare a variable to hold all results
results := make(map[string]result)

// use `for` and `range` to retrieve data from channel
for res := range ch {
    id := res[0].(string)
    person := res[1].(person)

    // append it to the map
    result[id] = person
}

// and do something with all the results once completed

另一种方法是使用 sync.mutex 和 sync.waitgroup 等少数 sync api 来实现相同的目标。

// prepare a variable to hold all results
results := make(map[string]result)

// prepare a mutex object with purpose is to lock and unlock operations related to `results` variable, to avoid data race.
mtx := new(sync.mutex)

// prepare a waitgroup object for effortlessly waits for goroutines to finish
wg := new(sync.waitgroup)

// tell the waitgroup object how many goroutines that need to be finished
wg.add(people)

for id, person := range people {

    // dispatch an iife as goroutine, so no need to change the `someapicall()`
    go func(id string, person person) {
        result := someapicall(person)

        // lock the append operation on `results` variable to avoid data race
        mtx.lock()
        results[id] = result
        mtx.unlock()

        // tell waitgroup object that one goroutine is just finished
        wg.done()
    }(id, person)
}

// block the process synchronously till all goroutine finishes.
// after that it'll continue to next process underneath
wg.wait()

// and do something with all the results once completed

警告。上述两种方法都适用于需要迭代的数据很少的情况。如果太多的话就不好了，几乎同时调度大量的goroutine，并且会导致机器内存使用率非常高。我建议看一下worker pool technique来改进代码。

你可以使用goroutine并行调用api：

type Item struct {
    id string
    res Result
}

func callApi(id string, person Result, resultChannel chan Item) {
    res := someApiCall(person)
    resultChannel <- Item{id, res}
}

resultChannel := make(chan Item)
for id, person := range people {
    go callApi(id, person, resultChannel)
}

result := make(map[string]Result)
for range people {
    item := <- resultChannel
    result[item.id] = item.res
}

但是，上面的代码忽略了错误处理，例如someapicall 可能会失败或panic，如果人数过多，会导致并行的api调用过多，通常情况下，您应该限制并行的api调用数量。我会把这些问题留给你作为练习

今天关于《优化 API 请求的循环方法》的内容就介绍到这里了，是不是学起来一目了然！想要了解更多关于的内容请关注golang学习网公众号！