Question

我刚接触Golang，发现转到频道非常有趣。我的背景是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代码那样使它们可预测？

Answer 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"
}

Answer 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例程后，我们有一个循环，该循环仅通过使用通道检查所有例程是否已完成。之所以可行，是因为阻止从通道读取。

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

如何在golang中顺序处理并发请求？

2 个答案: