使用通道进行请求-响应通信的惯用方式

Question

也许我只是没有正确阅读规范，或者我的思维方式仍然停留在旧的同步方法上，但是在 Go 中发送一种类型作为接收其他类型作为响应的正确方法是什么？

我想出的一种方法是

package main
import "fmt"

type request struct {
    out chan string
    argument int
}
var input = make(chan *request)
var cache = map[int]string{}
func processor() {
    for {
        select {
            case in := <- input:
                if result, exists := cache[in.argument]; exists {
                    in.out <- result
                }
                result := fmt.Sprintf("%d", in.argument)
                cache[in.argument] = result
                in.out <- result
        }
    }
}

func main() {
    go processor()
    responseCh := make(chan string)
    input <- &request{
        responseCh,
        1,
    }
    result := <- responseCh
    fmt.Println(result)
}

对于这个例子来说，缓存并不是真正需要的，否则会导致数据争用。

这是我应该做的吗？

Answer 1

有很多可能性，取决于解决您的问题的最佳方法。当您从频道收到某些内容时，没有什么比默认的响应方式更好的了——您需要自己构建流程（您在问题的示例中肯定是这样做的）。随每个请求发送响应通道为您提供了极大的灵活性，因为您可以选择在每个请求中将响应路由到何处，但通常没有必要。

这里有一些其他的例子：

1.从同一频道发送和接收

您可以使用无缓冲通道来发送和接收响应。这很好地说明了无缓冲通道实际上是程序中的同步点。限制当然是我们需要发送与请求和响应完全相同的类型：

package main

import (
    "fmt"
)

func pow2() (c chan int) {
    c = make(chan int)
    go func() {
        for x := range c {
            c <- x*x
        }
    }()
    return c
}

func main() {
    c := pow2()
    c <- 2
    fmt.Println(<-c) // = 4
    c <- 4
    fmt.Println(<-c) // = 8
}

2。发送到一个频道，从另一个频道接收

您可以分离输入和输出通道。如果您愿意，您可以使用缓冲版本。这可以用作请求/响应场景，并允许您拥有一个负责发送请求的路由，另一个负责处理它们，另一个负责接收响应。示例：

package main

import (
    "fmt"
)

func pow2() (in chan int, out chan int) {
    in = make(chan int)
    out = make(chan int)
    go func() {
        for x := range in {
            out <- x*x
        }       
    }()
    return
}

func main() {
    in, out := pow2()
    go func() {
        in <- 2
        in <- 4
    }()
    fmt.Println(<-out) // = 4
    fmt.Println(<-out) // = 8
}

3.随每个请求发送响应通道

这就是您在问题中提出的内容。使您可以灵活地指定响应路线。如果您希望响应命中特定的处理例程，这很有用，例如，您有许多客户端有一些任务要做，并且您希望响应被同一个客户端接收。

package main

import (
    "fmt"
    "sync"
)

type Task struct {
    x int
    c chan int
}

func pow2(in chan Task) {
    for t := range in {
        t.c <- t.x*t.x
    }       
}

func main() {
    var wg sync.WaitGroup   
    in := make(chan Task)

    // Two processors
    go pow2(in)
    go pow2(in)

    // Five clients with some tasks
    for n := 1; n < 5; n++ {
        wg.Add(1)
        go func(x int) {
            defer wg.Done()
            c := make(chan int)
            in <- Task{x, c}
            fmt.Printf("%d**2 = %d\n", x, <-c)
        }(n)
    }

    wg.Wait()
}

值得一提的是，这种场景不需要通过每个任务返回通道来实现。如果结果包含某种客户端上下文（例如客户端 ID），则单个多路复用器可能会接收所有响应，然后根据上下文处理它们。

有时让渠道参与来实现简单的请求-响应模式是没有意义的。在设计 Go 程序时，我发现自己试图在系统中注入太多通道（只是因为我认为它们真的很棒）。有时我们只需要旧的好函数调用：

package main

import (
    "fmt"
)

func pow2(x int) int {
    return x*x
}

func main() {
    fmt.Println(pow2(2))
    fmt.Println(pow2(4))
}

（如果有人遇到与您的示例类似的问题，这可能是一个很好的解决方案。回应您在问题下收到的 cmets，必须保护单个结构，例如缓存，它可能 最好创建一个结构并暴露一些方法，这将保护与互斥体的并发使用。）