Golang 采用两个单向接收通道和一个发送通道

单向通道是一种只能用于发送数据或接收数据的通道类型，不能同时用于两者。在这个Golang文章中，我们将探索一个使用select语句和使用扇入模式的方法，该方法使用两个单向接收通道和一个发送通道。我们将提供带有代码示例、算法和代码输出的示例。

方法1：使用Select语句

这种方法允许您同时处理多个通道操作，并选择准备好进行处理的通道。

步骤

创建三个通道：channel1、channel2和out。
启动一个goroutine来运行combineChannels函数，将channel1、channel2和out作为参数传递。
在combineChannels函数内部，执行以下操作：
- 使用range循环从channel1接收值，并将每个值传输到out通道。
- 在channel1关闭后，使用range循环从channel2接收值，并将每个值传输到out通道。
- 关闭out通道。
在主函数中初始化channel1、channel2和out通道。
使用range循环从out通道接收值，并打印每个接收到的值。

示例

下面的示例演示了一种使用goroutine将多个通道中的值合并到一个通道的方法。

package main

import "fmt"

func combineChannels(channel1 <-chan int, channel2 <-chan int, out chan<- int) {
   for val := range channel1 {
      out <- val
   }

   for val := range channel2 {
      out <- val
   }

   close(out)
}

func main() {
   channel1 := make(chan int)
   channel2 := make(chan int)
   out := make(chan int)

   go combineChannels(channel1, channel2, out)

   go func() {
      channel1 <- 1
      channel1 <- 3
      close(channel1)
   }()

   go func() {
      channel2 <- 2
      channel2 <- 4
      close(channel2)
   }()

   for val := range out {
      fmt.Println(val)
   }
}

输出

方法2：使用Fn-In模式

Fn-In代表函数中的函数，是一种适应性的管理来自多个路由的值的方式。它允许您将来自多个通道的值分别管理，并对每个通道的值执行各种操作。

步骤

创建三个通道：channel1，channel2和out。
创建一个初始计数为2的sync.WaitGroup，名为wg。
启动两个goroutines：Goroutine 1：mergeChannels（channel1，channel2，out，＆wg）
在mergeChannels内部：创建另一个初始计数为2的sync.WaitGroup，名为mergeWG。
启动两个goroutines−
使用wg.Done（）来递减wg的计数。
创建一个名为results的切片来存储合并的值，并使用for val：= range out来迭代out通道：将每个接收到的值附加到results切片中。
使用sort.Ints（results）对结果切片按升序进行排序，并迭代排序后的结果切片并打印每个值。

示例

下面给出的代码演示了一种将两个输入通道的值合并到一个输出通道的方法。然后对合并的值进行排序和显示。

package main

import (
   "fmt"
   "sort"
   "sync"
)

func receiveFromChannel(channel <-chan int, out chan<- int) {
   defer close(out)
   for val := range channel {
      out <- val
   }
}

func mergeChannels(channel1 <-chan int, channel2 <-chan int, out chan<- int, wg *sync.WaitGroup) {
   defer close(out)

   var mergeWG sync.WaitGroup
   mergeWG.Add(2)

   go func() {
      defer mergeWG.Done()
      receiveFromChannel(channel1, out)
   }()

   go func() {
      defer mergeWG.Done()
      receiveFromChannel(channel2, out)
   }()

   mergeWG.Wait()
   wg.Done()
}

func main() {
   channel1 := make(chan int)
   channel2 := make(chan int)
   out := make(chan int)

   var wg sync.WaitGroup
   wg.Add(2)

   go mergeChannels(channel1, channel2, out, &wg)

   go func() {
      defer close(channel1)
      channel1 <- 1
      channel1 <- 3
   }()

   go func() {
      defer close(channel2)
      channel2 <- 2
      channel2 <- 4
   }()

   go func() {
      wg.Wait()
      close(out)
   }()

   var results []int
   for val := range out {
      results = append(results, val)
   }

   sort.Ints(results)

   for _, val := range results {
      fmt.Println(val)
   }
}