如何在Go中选择动态通道列表上的输入？

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

how to select for input on a dynamic list of channels in Go?

问题

Go有一种机制可以从多个通道中进行阻塞读取，即select语句。因此，你可以这样说：

  1. select {
  2.     case <- c1:
  3.     case <- c2:
  4. }

将会阻塞，直到从这两个通道中的任意一个接收到输入。非常好。

但是，这要求我在源代码中指定我要轮询的通道数量。如果我有一个通道的切片或数组，并且我希望在任何一个通道上接收到输入之前进行阻塞，该怎么办？

英文:

Go has a mechanism to do a blocking read from one of several channels, the select statement. So you can say

  1. select {
  2.     case <- c1:
  3.     case <- c2:
  4. }

will block until we get input from either of these two channels. Very nice.

But this requires that I specify in the source code how many channels I want to poll. What if I have a slice or array of channels and I want to block until I get input on any of them?

答案1

得分: 8

自从go1.1版本以来，有一个适当的API可以动态地进行选择集操作。

下面是一个完整且可用的示例：

  1. package main
  3. import (
  4.     "log"
  5.     "reflect"
  6. )
  8. func sendToAny(ob int, chs []chan int) int {
  9.     set := []reflect.SelectCase{}
  10.     for _, ch := range chs {
  11.         set = append(set, reflect.SelectCase{
  12.             Dir:  reflect.SelectSend,
  13.             Chan: reflect.ValueOf(ch),
  14.             Send: reflect.ValueOf(ob),
  15.         })
  16.     }
  17.     to, _, _ := reflect.Select(set)
  18.     return to
  19. }
  21. func recvFromAny(chs []chan int) (val int, from int) {
  22.     set := []reflect.SelectCase{}
  23.     for _, ch := range chs {
  24.         set = append(set, reflect.SelectCase{
  25.             Dir:  reflect.SelectRecv,
  26.             Chan: reflect.ValueOf(ch),
  27.         })
  28.     }
  29.     from, valValue, _ := reflect.Select(set)
  30.     val = valValue.Interface().(int)
  31.     return
  32. }
  34. func main() {
  35.     channels := []chan int{}
  36.     for i := 0; i < 5; i++ {
  37.         channels = append(channels, make(chan int))
  38.     }
  40.     go func() {
  41.         for i := 0; i < 10; i++ {
  42.             x := sendToAny(i, channels)
  43.             log.Printf("Sent %v to ch%v", i, x)
  44.         }
  45.     }()
  47.     for i := 0; i < 10; i++ {
  48.         v, x := recvFromAny(channels)
  49.         log.Printf("Received %v from ch%v", v, x)
  50.     }
  51. }

您可以在playground上进行交互式操作。

英文:

Since go1.1, there's a proper API to dynamically do select sets.

Here's a complete and usable example:

  1. package main
  3. import (
  4. 	&quot;log&quot;
  5. 	&quot;reflect&quot;
  6. )
  8. func sendToAny(ob int, chs []chan int) int {
  9. 	set := []reflect.SelectCase{}
  10. 	for _, ch := range chs {
  11. 		set = append(set, reflect.SelectCase{
  12. 			Dir:  reflect.SelectSend,
  13. 			Chan: reflect.ValueOf(ch),
  14. 			Send: reflect.ValueOf(ob),
  15. 		})
  16. 	}
  17. 	to, _, _ := reflect.Select(set)
  18. 	return to
  19. }
  21. func recvFromAny(chs []chan int) (val int, from int) {
  22. 	set := []reflect.SelectCase{}
  23. 	for _, ch := range chs {
  24. 		set = append(set, reflect.SelectCase{
  25. 			Dir:  reflect.SelectRecv,
  26. 			Chan: reflect.ValueOf(ch),
  27. 		})
  28. 	}
  29. 	from, valValue, _ := reflect.Select(set)
  30. 	val = valValue.Interface().(int)
  31. 	return
  32. }
  34. func main() {
  35. 	channels := []chan int{}
  36. 	for i := 0; i &lt; 5; i++ {
  37. 		channels = append(channels, make(chan int))
  38. 	}
  40. 	go func() {
  41. 		for i := 0; i &lt; 10; i++ {
  42. 			x := sendToAny(i, channels)
  43. 			log.Printf(&quot;Sent %v to ch%v&quot;, i, x)
  44. 		}
  45. 	}()
  47. 	for i := 0; i &lt; 10; i++ {
  48. 		v, x := recvFromAny(channels)
  49. 		log.Printf(&quot;Received %v from ch%v&quot;, v, x)
  50. 	}
  51. }

You can play around with it interactively on the playground

答案2

得分: 5

只是一个想法，但你可以使用多路复用模式，其中你可以生成一个带有2个通道的goroutine，它会在这两个通道上阻塞并将输出发送到一个新的通道。然后你可以动态地从列表中构建这些通道的树状结构，将所有内容汇聚到一个单一的通道中，然后在该通道上进行读取。

英文:

Just a thought, but you could use a multiplexing pattern, where you spawn off a goroutine with 2 channels that blocks on both and sends the output to a new channel. Then you can just build up a tree of these dynamically from your list that funnels everything down to a single channel, which you then read on.

答案3

得分: 4

包主要

导入 "fmt"

功能 主要() {
c1 := make(chan int)
c2 := make(chan int)

  1. 去 功能() { c1 <- 1 }()
  2. 去 功能() { c2 <- 2 }()
  4. cs := []chan int{c1, c2}
  5. cm := make(chan [2]int)
  7. 对于 idx, c := 范围(cs) {
  8.     去 功能(idx int, c chan int) {
  9.         cm <- [2]int{idx, <-c}
  10.     }(idx, c)
  11. }
  13. fmt.Print(<-cm)
  14. fmt.Print(<-cm)

}

打印 [0 1][1 2] (或者可能是 [1 2][0 1])。

英文: 
  1. package main
  3. import &quot;fmt&quot;
  5. func main() {
  6.     c1 := make(chan int)
  7.     c2 := make(chan int)
  9.     go func() { c1 &lt;- 1 }()
  10.     go func() { c2 &lt;- 2 }()
  12.     cs := []chan int{c1, c2}
  13.     cm := make(chan [2]int)
  15.     for idx, c := range(cs) {
  16.         go func(idx int, c chan int) {
  17.             cm &lt;- [2]int{idx, &lt;-c}
  18.         }(idx, c)
  19.     }
  21.     fmt.Print(&lt;-cm)
  22.     fmt.Print(&lt;-cm)
  23. }

prints [0 1][1 2] (or maybe [1 2][0 1]).

答案4

得分: 1

也许可以这样实现？

  1. // multiplex函数接受一个chan int的切片，并返回一个chan int，用于在所有通道之间进行复用。
  2. func multiplex(chs []<-chan int) <-chan int {
  3.     c := make(chan int)
  4.     d := make(chan bool)
  5.     for _, ch := range chs {
  6.         go func(ch <-chan int) {
  7.             for r := range ch {
  8.                 c <- r
  9.             }
  10.             d <- true
  11.         }(ch)
  12.     }
  13.     go func() {
  14.         for i := 0; i < len(chs); i++ {
  15.             <-d
  16.         }
  17.         close(c)
  18.     }()
  19.     return c
  20. }
英文:

Perhaps something like this may apply?

  1. // multiplex takes a slice of chan ints and returns a channel
  2. // that multiplexes between all of them.
  3. func multiplex(chs []&lt;-chan int) &lt;-chan int {
  4. 	c := make(chan int)
  5. 	d := make(chan bool)
  6. 	for _, ch := range chs {
  7. 		go func(ch &lt;-chan int) {
  8. 			for r := range ch {
  9. 				c &lt;- r
  10. 			}
  11. 			d &lt;- true
  12. 		}(ch)
  13. 	}
  14. 	go func() {
  15. 		for i := 0; i &lt; len(chs); i++ {
  16. 			&lt;-d
  17. 		}
  18. 		close(c)
  19. 	}()
  20. 	return c
  21. }

huangapple
  • 本文由 发表于 2010年11月19日 07:30:53
  • 转载请务必保留本文链接：https://go.coder-hub.com/4220745.html
  • channel
  • go
匿名

发表评论

匿名网友

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

确定