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

（如果有人遇到与你的例子中类似的问题，这可能是一个很好的解决方案。回应你在问题中收到的评论，必须保护单个结构，如缓存，可能最好创建一个结构并公开一些方法，这样可以保护与互斥锁的并发使用。）

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

1 个答案: