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

Question

也许我只是没有正确阅读规范，或者我的心态仍然坚持使用旧的同步方法，但是在 Go中发送一种类型作为接收其他类型作为响应的正确方法是什么？我想出的一种方法是package mainimport "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))

}

（如果有人遇到类似的问题，因为在你的榜样，这可能是一个很好的解决方案。附和你的问题下收到的意见，为保护单个结构，诸如高速缓存，它可能是最好创建一个结构和揭露一些方法，这将保护与互斥锁的并发使用。）