通道就绪后，从多个通道中选择所有值

Question

我是golang ，我遇到了这个问题。

我有几个channel 。

一些有效负载在不同的时间到达此通道。

当通道准备吐痰时，如何从通道一个接一个地获取所有值。

例如，我编写了以下代码：

包主

import (
    "fmt"
    "time"
    "math/rand"
)

func main() {
    arr1 := []int8{1,2,3,4,5}
    arr2 := []int8{6,7,8,9,10}

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

    go func() {
        for _, val := range arr1 {
            time.Sleep(time.Duration(rand.Intn(100)) * time.Millisecond)
            c1 <- val
        }
    }()
    go func() {
        for _, val := range arr2 {
            time.Sleep(time.Duration(rand.Intn(100)) * time.Millisecond)
            c2 <- val
        }
    }()

    select {
        case res1 := <- c1:
            fmt.Println(res1)
        case res2 := <- c2:
            fmt.Println(res2)
    }

    fmt.Println("Hello, test")
}

但是在这种情况下，我只能从其中一个渠道获得第一个价值。

请给我建议如何解决我的问题。

链接至播放https://play.golang.org/p/FOmkP57YCyR

Answer 1

您必须做几件事。

1）完成源处理后，请确保关闭频道。 2）遍历通道，直到关闭通道。

例：

package main

import (
    "fmt"
    "math/rand"
    "time"
)

func main() {
    arr1 := []int8{1, 2, 3, 4, 5}
    arr2 := []int8{6, 7, 8, 9, 10}

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

    go func() {
        for _, val := range arr1 {
            time.Sleep(time.Duration(rand.Intn(100)) * time.Millisecond)
            c1 <- val
        }
        close(c1)
    }()
    go func() {
        for _, val := range arr2 {
            time.Sleep(time.Duration(rand.Intn(100)) * time.Millisecond)
            c2 <- val
        }
        close(c2)
    }()

    _c1 := true
    _c2 := true
    var res1, res2 int8

    for _c1 == true || _c2 == true {
        select {
        case res1, _c1 = <-c1:
            if _c1 == true {
                fmt.Println(res1)
            }
        case res2, _c2 = <-c2:
            if _c2 == true {
                fmt.Println(res2)
            }
        }
    }

    fmt.Println("Hello, test")
}

执行后，我在屏幕上得到以下输出。

6
1
7
2
3
4
8
5
9
10
Hello, test

Answer 2

您不必使用2个频道。 只需使用1个通道并从多个goroutine中将值存储到其中即可。 Channel是一种轻量级的线程连接器，它速度很快，可以实例化多次以存储来自多个goroutine的值。

您的代码的问题在于它没有循环来循环来自goroutines通道的值。 您只能使用select打印一次。 select使其他goroutines等待执行它可能遇到的情况之一。 如果所有情况都可能，那么它将随机选择执行。

您只能从通道中获得一个值的原因是，当goroutine运行时，它们将数组中的值顺序存储到通道中。 发生这种情况时，您可以在主线程中调用带有case的select语句，以从goroutines的通道中获取值。 由于您不循环访问通道，因此只能从通道中获得一个值，该值是它首先收到的值。 在这种情况下，您可以在goroutines中依次将数组循环到channel中，因此您将获得数组的第一个索引，因为它是将首先发送到主线程中的select语句的值。 您可能会执行所有选择的案例，因此它将随机执行其中一种案例，您将在其中一个数组中获得第一个索引。

要解决此问题，您需要遍历通道以逐个获取存储在其中的值。 另外，您还需要同步所有线程，以避免死锁情况，这种情况发生在您的主线程不知道何时停止从goroutines调用通道时，因为它们是异步工作的。 您的通道准备好在goroutines中获取值并在循环中将其调用到主线程后立即吐出值。 这是代码：

package main

import (
    "fmt"
    "time"
    "math/rand"
    "sync"
)

// writer set numbers from array to channel
func writer(ch chan int, arr []int ,wgwrite *sync.WaitGroup) {
    defer wgwrite.Done()
    for _, val := range arr {
        time.Sleep(time.Duration(rand.Intn(100)) * time.Millisecond)
        ch <- val
    }
}

// reader receive input from writer channels and print them all 
func reader(ch chan int, wgread *sync.WaitGroup) {
  defer wgread.Done()
  for i:= range ch {
    fmt.Println(i)
  }
  fmt.Println("Hello, test")
}

func main() {
    arr1 := []int{1,2,3,4,5}
    arr2 := []int{6,7,8,9,10}
    ch := make(chan int)
    wgwrite := &sync.WaitGroup{}
    wgread  := &sync.WaitGroup{}

    wgwrite.Add(2)
    go writer(ch, arr1, wgwrite)
    go writer(ch, arr2, wgwrite)

    wgread.Add(1)
    go reader(ch, wgread)

    wgwrite.Wait()
    close(ch)
    wgread.Wait()
}

https://play.golang.org/p/32Fgetq_Zu7

希望能帮助到你。

Answer 3

Select不等待执行例程。 为此，您应该将其包装在for语句中。 这样， select将一直运行，直到其中一种情况返回并中断for语句为止。

for {
   select {
      ...

您也可以使用非阻塞和等待组的缓冲通道。 像这样：

arr1 := []int8{1,2,3,4,5}
arr2 := []int8{6,7,8,9,10}

c1 := make(chan int8, len(arr1))
c2 := make(chan int8, len(arr2))

var wg sync.WaitGroup

wg.Add(1) // First wait group
go func() {
    for _, val := range arr1 {
        time.Sleep(time.Duration(rand.Intn(100)) * time.Millisecond)
        c1 <- val
    }
    wg.Done()
}()

wg.Add(1) // Second wait group
go func() {
    for _, val := range arr2 {
        time.Sleep(time.Duration(rand.Intn(100)) * time.Millisecond)
        c2 <- val
    }
    wg.Done()
}()

// executed after wg.Done() is called 2 times since we have 2 wait groups
wg.Wait() 

// We are not writing to channels anymore so we can close them.
close(c1)
close(c2)

for value := range c1 {
    fmt.Println(value)
}

for value := range c2 {
    fmt.Println(value)
}


fmt.Println("Hello, test")