选择多个case一次性执行

huangapple go评论80阅读模式
英文:

Go Select and multiple cases at once

问题

如何将下面的代码修改为在接收到C1和C2时执行某些操作?

import "time"
import "fmt"

func main() {

    c1 := make(chan string)
    c2 := make(chan string)

    go func() {
        time.Sleep(time.Second * 1)
        c1 <- "one"
    }()
    go func() {
        time.Sleep(time.Second * 2)
        c2 <- "two"
    }()

    for i := 0; i < 2; i++ {
        select {
        case msg1 := <-c1:
            fmt.Println("received", msg1)
        case msg2 := <-c2:
            fmt.Println("received", msg2)
        }
    }
}

将代码修改为在接收到C1和C2时执行某些操作,可以使用一个额外的goroutine来处理这个逻辑。修改后的代码如下所示:

import "time"
import "fmt"

func main() {

    c1 := make(chan string)
    c2 := make(chan string)
    done := make(chan bool) // 用于通知操作完成的通道

    go func() {
        time.Sleep(time.Second * 1)
        c1 <- "one"
    }()
    go func() {
        time.Sleep(time.Second * 2)
        c2 <- "two"
    }()

    go func() {
        for i := 0; i < 2; i++ {
            select {
            case msg1 := <-c1:
                fmt.Println("received", msg1)
            case msg2 := <-c2:
                fmt.Println("received", msg2)
            }
        }
        done <- true // 所有操作完成后发送通知
    }()

    <-done // 等待操作完成

}

这样修改后的代码会在接收到C1和C2时执行相应的操作,并在所有操作完成后结束程序。

英文:

How to adapt the code below to do something when C1 and C2 have been BOTH received
https://gobyexample.com/select

import &quot;time&quot;
import &quot;fmt&quot;

func main() {

    c1 := make(chan string)
    c2 := make(chan string)

    go func() {
        time.Sleep(time.Second * 1)
        c1 &lt;- &quot;one&quot;
    }()
    go func() {
        time.Sleep(time.Second * 2)
        c2 &lt;- &quot;two&quot;
    }()

    for i := 0; i &lt; 2; i++ {
        select {
        case msg1 := &lt;-c1:
            fmt.Println(&quot;received&quot;, msg1)
        case msg2 := &lt;-c2:
            fmt.Println(&quot;received&quot;, msg2)
        }
    }
}

答案1

得分: 5

这可能是一种称为"fan-in"的管道技术

一个函数可以从多个输入中读取,并在所有输入关闭时通过将输入通道多路复用到一个单一通道上来继续执行,当所有输入都关闭时,该通道也关闭。这被称为"fan-in"。

func merge(cs ...<-chan int) <-chan int {
    var wg sync.WaitGroup
    out := make(chan string)

    // 为cs中的每个输入通道启动一个输出goroutine。output将值从c复制到out,直到c关闭或从done接收到一个值,然后output调用wg.Done。
    output := func(c <-chan string) {
        for n := range c {
            select {
            case out <- "received " + n:
            case <-done:
            }
        }
        wg.Done()
    }
    wg.Add(len(cs))
    for _, c := range cs {
        go output(c)
    }

    // 启动一个goroutine,在所有输出goroutine完成后关闭out。这必须在wg.Add调用之后启动。
    go func() {
        wg.Wait()
        close(out)
    }()
    return out
}

在这个playground中可以看到一个完整的示例。


注意:无论你最终使用什么解决方案,都可以阅读一下这篇文章:

使用通道设计Go API的原则,作者是Alan Shreve

特别是:

原则 #1

API应该声明其通道的方向性

英文:

That could be a pipeline technique, called fan-in:

> A function can read from multiple inputs and proceed until all are closed by multiplexing the input channels onto a single channel that's closed when all the inputs are closed. This is called fan-in.

func merge(cs ...&lt;-chan int) &lt;-chan int {
    var wg sync.WaitGroup
    out := make(chan string)

    // Start an output goroutine for each input channel in cs.  output
    // copies values from c to out until c is closed or it receives a value
    // from done, then output calls wg.Done.
    output := func(c &lt;-chan string) {
        for n := range c {
            select {
            case out &lt;- &quot;received &quot; + n:
            case &lt;-done:
            }
        }
        wg.Done()
    }
    wg.Add(len(cs))
    for _, c := range cs {
        go output(c)
    }

    // Start a goroutine to close out once all the output goroutines are
    // done.  This must start after the wg.Add call.
    go func() {
        wg.Wait()
        close(out)
    }()
    return out
}

See a complete example in this </kbd>playground</kbd>


Note: whatever solution you will end up using, a good read remains:

Principles of designing Go APIs with channels by Alan Shreve.

In particular:

Principle #1

> An API should declare the directionality of its channels.

huangapple
  • 本文由 发表于 2014年7月18日 21:30:06
  • 转载请务必保留本文链接:https://go.coder-hub.com/24826225.html
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定