如何在golang中顺序处理并发请求？ [复制]答案

【问题标题】：How to handle concurrent request sequentially in golang? [duplicate]如何在golang中顺序处理并发请求？ [复制]
【发布时间】：2019-04-11 23:03:51
【问题描述】：

我是 Golang 的新手，我发现 Go 频道非常有趣。我的背景来自 JavaScript，我想在 Go 中按顺序处理并发请求，有点像 JavaScript 中的Promise.all()。我想要的只是发出一些并发运行的请求，并按照我调用它们的顺序处理返回的数据。

等效的 JavaScript 代码如下：

async function main() {
  // Assuming all db calls will return a promise
  const firstUserPromise = firstDbCall().then((res) => res);
  const secondUserPromise = secondDbCall().then((res) => res);
  const thridUserPromise = thridDbCall().then((res) => res);

  const [
    firstUserData,
    secondUserData,
    thirdUserData
  ] = await Promise.all([firstUserPromise, secondUserPromise, thirdUserPromise]);
}

如果您不熟悉 JavaScript，在上面的代码中，我会同时进行三个数据库调用（从第 3 行到第 5 行）。然后我在等待他们给出一些回应（从第 7 行到第 10 行）。这段代码的好处在于，当所有三个数据库调用都完成后，我将按照等待它们的顺序获得结果。 firstUserData 会收到来自firstUserPromise 的回复，secondUserData 会收到来自secondUserPromise 等等。

下面是一个假设的代码，我希望它等同于上面的 JavaScript 代码：

package main

import "fmt"

func main() {
  set = make(chan, string)
  get = make(chan, string)

  // First DB call
  go firstDbCall()
  // Second DB call
  go secondDbCall()
  // Third DB call
  go thirdDbCall()

  // How to make sending data to channels predictable
  // First data to `set` channel will send data to firstDbCall
  // Second one will `set` to secondDbCall and so on.
  set <- "userId 1"
  set <- "userId 2"
  set <- "userId 3"

  // Similarly, How to make receiving data from channels predictable
  // firstUserData will data of "userId 1", secondUserData will have
  // data of "userId 2" and so on.
  firstUserData := <-get
  secondUserData := <-get
  thirdUserData := <-get
}

由于从通道获取数据是不可预测的，我怎样才能让它们像 JavaScript 代码一样可预测？

【问题讨论】：

让每个 goroutine 将其结果填充到切片中自己的元素中。
@Mohammad_Aziz 关注第一条评论。它不仅说明您的问题的重复性，而且还提及您正在寻找的答案。如果这没有帮助，请在需要时回复此社区的帮助。
为什么不将函数作为参数传递给 db 调用，并在那里处理？
您关心函数的执行顺序还是关心结果处理的顺序？如果是第一个，你应该按顺序做事，没有渠道或套路。如果是第二个，则使用 WaitGroup 等待所有 goroutine 完成，让它们将结果存储在预定义的切片或数组中，并以您认为正确的任何顺序处理结果数组。
我不知道WaitGroup 以及它是如何工作的。我确实关心处理结果的顺序@MadWombat。

标签： javascript go concurrency promise channel

【解决方案1】：

Go 通道实际上只是线程安全的队列。在这种情况下，它看起来不像队列（因此是通道）适合您的用例。我建议查看sync.WaitGroup。

package main

import "sync"

func main() {
    var (
        firstUserData, secondUserData, thirdUserData string
        wg                                           sync.WaitGroup
    )
    wg.Add(3)

    // First DB call
    go func() {
        defer wg.Done()
        firstUserData = firstDbCall()
    }()

    // Second DB call
    go func() {
        defer wg.Done()
        secondUserData = secondDbCall()
    }()

    // Third DB call
    go func() {
        defer wg.Done()
        thirdUserData = thirdDbCall()
    }()

    wg.Wait()

    println(firstUserData, secondUserData, thirdUserData)
}

func firstDbCall() string {
    return "UserId1"
}

func secondDbCall() string {
    return "UserId2"
}

func thirdDbCall() string {
    return "UserId3"
}

【讨论】：

您应该查看问题中的 cmets。此外，您的解决方案似乎并不像预期的那样。您刚刚将字符串分配到相应的 var 中。你不关心并发 goroutine 的完成顺序。
原始示例代码也不关心顺序。它是 3 个不同的函数调用。
也许你是对的。
@poy 我可以保证您的回答确实涵盖了我的解决方案。只是出于好奇，如果我关心完成订单，你会建议什么？
什么意思？想对订单做什么？

【解决方案2】：

您想为此使用 go 例程和通道。如果顺序很重要，您可以使用定义大小的切片，如下所示：

package main

import "fmt"

func firstDBCall(resultSlice *[]string, doneChannel chan bool) {
    (*resultSlice)[0] = "1"
    doneChannel <- true
}

func secondDBCall(resultSlice *[]string, doneChannel chan bool) {
    (*resultSlice)[1] = "2"
    doneChannel <- true 
}

func thirdDBCall(resultSlice *[]string, doneChannel chan bool) {
    (*resultSlice)[2] = "3"
    doneChannel <- true
}

func main() {
    resultSlice := make([]string, 3)
    doneChannel := make(chan bool)
    go firstDBCall(&resultSlice, doneChannel)
    go secondDBCall(&resultSlice, doneChannel)
    go thirdDBCall(&resultSlice, doneChannel)

    for i := 0; i < 3; i++ {
        <-doneChannel
    }
    fmt.Println(resultSlice)
}

这段代码使用 go 关键字同时调用三个函数。在切片填充的位置，您将首先进行数据库查询，然后再将结果填充到切片中。调用 go 例程后，我们有一个循环，它只使用通道检查所有例程是否已完成。这是有效的，因为从通道中读取是阻塞的。

另一个可能更优雅的解决方案是使用结构而不是切片。这也将允许不同类型的查询值。

【讨论】：