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

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)
}

对于此示例,该缓存不是必需的,否则会导致datarace.

这是我应该做的吗？

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),则单个多路复用器可以接收所有响应,然后根据上下文处理它们.

有时,涉及通道以实现简单的请求 - 响应模式是没有意义的.在设计程序时,我发现自己试图向系统中注入太多通道(仅仅因为我认为它们真的很棒).旧的好函数调用有时是我们所需要的:

package main

import (
    "fmt"
)

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

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

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