13

这个想法是在一个切片中拥有可变数量的通道，将通过它们接收到的每个值推送到单个通道中，并在最后一个输入通道关闭后关闭此输出通道。像这样的东西，但对于两个以上的频道：

func multiplex(cin1, cin2, cout chan int) {
    n := 2
    for {
        select {
        case v, ok := <-cin1:
            if ok {
                cout <- v
            } else {
                n -= 1
            }

        case v, ok := <-cin2:
            if ok {
                cout <- v
            } else {
                n -= 1
            }
        }

        if n == 0 {
            close(cout)
            break
        }
    }
}

上面的代码避免了繁忙的循环，因为没有default案例，这很好（编辑：看起来“，ok”的存在使得选择语句非阻塞并且循环毕竟是繁忙的。但是为了示例，把代码想象成它会阻塞）。是否也可以通过任意数量的输入通道来实现相同的功能？显然，这可以通过将切片成对地减少到单个通道来完成，但如果可能的话，我会对更简单的解决方案更感兴趣。

4

3 回答 3

27

我相信这个片段可以满足您的需求。我已经更改了签名，因此很明显输入和输出只能用于一个方向的通信。注意添加 a sync.WaitGroup，您需要某种方式让所有输入都表示它们已完成，这很容易。

func combine(inputs []<-chan int, output chan<- int) {
  var group sync.WaitGroup
  for i := range inputs {
    group.Add(1)
    go func(input <-chan int) {
      for val := range input {
        output <- val
      }
      group.Done()
    } (inputs[i])
  }
  go func() {
    group.Wait()
    close(output)
  } ()
}
于 2012-06-11T18:12:57.260 回答
3

编辑：添加了成对减少示例代码并重新排序了部分答案。

首选的解决方案是不回答“重组，使您没有渠道切片”。重构通常可以利用多个 goroutine 可以发送到单个通道的特性。因此，不必让每个源在单独的通道上发送，然后不得不处理从一堆通道接收，只需创建一个通道并让所有源在该通道上发送。

Go 不提供从通道切片接收的功能。这是一个经常被问到的问题，虽然刚刚给出的解决方案是首选的，但有一些方法可以对其进行编程。我认为您在原始问题中建议的解决方案是“成对减少切片”是二进制分而治之的解决方案。只要您有将两个通道多路复用为一个的解决方案，它就可以正常工作。您的示例代码非常接近工作。

你只是错过了一个让你的示例代码工作的小技巧。在减少 n 的地方，添加一行将通道变量设置为 nil。例如，我使代码读取

    case v, ok := <-cin1:
        if ok {
            cout <- v
        } else {
            n--
            cin1 = nil
        }
    case v, ok := <-cin2:
        if ok {
            cout <- v
        } else {
            n--
            cin2 = nil
        }
    }

该解决方案可以满足您的需求，并且不会忙于等待。

那么，一个完整的例子将这个解决方案合并到一个多路复用切片的函数中：

package main

import (
    "fmt"
    "time"
)

func multiplex(cin []chan int, cout chan int) {
    var cin0, cin1 chan int
    switch len(cin) {
    case 2:
        cin1 = cin[1]
        fallthrough
    case 1:
        cin0 = cin[0]
    case 0:
    default:
        cin0 = make(chan int)
        cin1 = make(chan int)
        half := len(cin) / 2
        go multiplex(cin[:half], cin0)
        go multiplex(cin[half:], cin1)
    }
    for cin0 != nil || cin1 != nil {
        select {
        case v, ok := <-cin0:
            if ok {
                cout <- v
            } else {
                cin0 = nil
            }
        case v, ok := <-cin1:
            if ok {
                cout <- v
            } else {
                cin1 = nil
            }
        }
    }
    close(cout)
}

func main() {
    cin := []chan int{
        make(chan int),
        make(chan int),
        make(chan int),
    }
    cout := make(chan int)
    for i, c := range cin {
        go func(x int, cx chan int) {
            for i := 1; i <= 3; i++ {
                time.Sleep(100 * time.Millisecond)
                cx <- x*10 + i
            }
            close(cx)
        }(i, c)
    }
    go multiplex(cin, cout)
    for v := range cout {
        fmt.Println("main gets", v)
    }
}
于 2012-06-11T16:29:54.727 回答
0

我使用 goroutines 制作了这个。是你想要的吗？

package main

import (
    "fmt"
)

func multiplex(cin []chan int, cout chan int) {
    n := len(cin)
    for _, ch := range cin {
        go func(src chan int) {
            for {
                v, ok := <-src
                if ok {
                    cout <- v
                } else {
                    n-- // a little dangerous. Maybe use a channel to avoid missed decrements
                    if n == 0 {
                        close(cout)
                    }
                    break
                }
            }
        }(ch)
    }
}

// a main to test the multiplex
func main() {
    cin := make([]chan int, 3)
    cin[0] = make(chan int, 2)
    cin[1] = make(chan int, 2)
    cin[2] = make(chan int, 2)
    cout := make(chan int, 2)
    multiplex(cin, cout)
    cin[1] <- 1
    cin[0] <- 2
    cin[2] <- 3
    cin[1] <- 4
    cin[0] <- 5
    close(cin[1])
    close(cin[0])
    close(cin[2])
    for {
        v, ok := <-cout
        if ok {
            fmt.Println(v)
        } else {
            break
        }
    }
}

编辑：参考：

http://golang.org/ref/spec#Receive_operator

http://golang.org/ref/spec#Close

于 2012-06-11T12:20:45.770 回答