Channel的典型应用场景

消息交流（生产者和消费者）

一个goroutine可以安全地往Channel中塞数据，另外一个goroutine可以安全地从Channel中读取数据，goroutine就可以安全地实现信息交流了，即生产者和消费者模式。
工作池是一组等待任务并处理任务的协程。

package main

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

type Task struct {
   id        int
   randomNum int
}

type Result struct {
   task               Task
   randomNumDigitsSum int
}

var taskCh = make(chan Task, 10)
var resultCh = make(chan Result, 10)

func createTasks(taskCount int) {
   for i := 0; i < taskCount; i++ {
      taskCh <- Task{i + 1, rand.Intn(999)}
   }
   close(taskCh)
}

func getRandomNumDigitsSum(num int) int {
   sum := 0
   for num > 0 {
      sum += num % 10
      num /= 10
   }
   time.Sleep(2 * time.Second)
   return sum
}

func work(wg *sync.WaitGroup) {
   for task := range taskCh {
      result := Result{task, getRandomNumDigitsSum(task.randomNum)}
      resultCh <- result
   }
   wg.Done()
}

func createWorkers(workerCount int) {
   var wg sync.WaitGroup
   for i := 0; i < workerCount; i++ {
      wg.Add(1)
      go work(&wg)
   }

   wg.Wait()
   close(resultCh)
}

func getResults(done chan bool) {
   for result := range resultCh {
      fmt.Printf("task id is %d, randomNum is %d, randomNumDigitsSum is %d\n",
         result.task.id, result.task.randomNum, result.randomNumDigitsSum)
   }
   done <- true
}

func main() {
   startTime := time.Now()

   taskCount := 100
   go createTasks(taskCount)

   workerCount := 10
   go createWorkers(workerCount)

   done := make(chan bool)
   go getResults(done)
   <-done

   endTime := time.Now()
   fmt.Printf("cost time: %fs\n", endTime.Sub(startTime).Seconds())
}

这里，工作池的任务是计算所输入数字的每一位的和。
taskCh和resultCh的通道容量都是10。
10个工作协程从taskCh里面不断获取值，把结果放入resultCh。
第一批10个任务进入taskCh后，每个工作协程获取后等待2s，第二批开始进入。
2s后，第二批就被每个工作协程获取到，第一批结果被打印出来。
直到结束，耗时大约20s。

 

运行结果

——————————等待2秒
task id is 4, randomNum is 983, randomNumDigitsSum is 20
task id is 2, randomNum is 636, randomNumDigitsSum is 15
task id is 10, randomNum is 150, randomNumDigitsSum is 6
task id is 7, randomNum is 520, randomNumDigitsSum is 7
task id is 5, randomNum is 895, randomNumDigitsSum is 22
task id is 9, randomNum is 904, randomNumDigitsSum is 13
task id is 8, randomNum is 998, randomNumDigitsSum is 26
task id is 3, randomNum is 407, randomNumDigitsSum is 11
task id is 1, randomNum is 878, randomNumDigitsSum is 23
task id is 6, randomNum is 735, randomNumDigitsSum is 15
——————————等待2秒
task id is 12, randomNum is 538, randomNumDigitsSum is 16
task id is 11, randomNum is 212, randomNumDigitsSum is 5
task id is 14, randomNum is 362, randomNumDigitsSum is 11
task id is 15, randomNum is 436, randomNumDigitsSum is 13
task id is 13, randomNum is 750, randomNumDigitsSum is 12
task id is 17, randomNum is 630, randomNumDigitsSum is 9
task id is 16, randomNum is 215, randomNumDigitsSum is 8
task id is 20, randomNum is 914, randomNumDigitsSum is 14
task id is 19, randomNum is 20, randomNumDigitsSum is 2
task id is 18, randomNum is 506, randomNumDigitsSum is 11
——————————等待2秒
一直到100...
cost time: 20.024336s

 

通过Go来处理每分钟达百万的数据请求：https://blog.csdn.net/tybaoerge/article/details/50392386

 

taskChPool里面的taskCh是非缓冲通道。
worker把自己的taskCh放入taskChPool，dispatch从taskChPool中取出taskCh并把task放入。
worker从自己的taskCh中取出任务并执行完成后，再次把自己的taskCh放入taskChPool，等待新的task。

如果每分钟一直是百万条数据请求，那么dispatch开启的协程不断堆积，直到内存超限。

 

package main

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

type Task struct {
   id        int
   randomNum int
}

type Worker struct {
   taskCh chan Task
}

var taskCh = make(chan Task, 10)
var taskChPool chan chan Task

func createTasks(taskCount int) {
   for i := 0; i < taskCount; i++ {
      taskCh <- Task{i + 1, rand.Intn(999)}
   }
   close(taskCh)
}

func getRandomNumDigitsSum(num int) int {
   sum := 0
   for num > 0 {
      sum += num % 10
      num /= 10
   }
   time.Sleep(2 * time.Second)
   return sum
}

func (w *Worker) work() {
   for {
      taskChPool <- w.taskCh
      if task, ok := <-w.taskCh; ok {
         fmt.Printf("task id is %d, randomNum is %d, randomNumDigitsSum is %d\n",
            task.id, task.randomNum, getRandomNumDigitsSum(task.randomNum))
      }
   }
}

func createWorkers(workerCount int) {
   for i := 0; i < workerCount; i++ {
      worker := Worker{make(chan Task)}
      go worker.work()
   }
}

func dispatch() {
   for task := range taskCh {
      go func(task Task) {
         taskCh := <-taskChPool
         taskCh <- task
      }(task)
   }
}

func main() {
   taskCount := 100
   go createTasks(taskCount)

   workerCount := 10
   go createWorkers(workerCount)

   taskChPool = make(chan chan Task, workerCount)
   go dispatch()

   time.Sleep(30 * time.Second)
}

 

两种方式对比：
请求是否会因处理请求过慢而阻塞。
第一个方案，会，如果处理请求过慢，那么会阻塞向taskCh里面放入task，相当于阻塞请求。
第二个方案，不会，如果处理请求过慢，那么把请求通过创建协程的方式来异步缓存起来，等worker有空了再执行，不是一直阻塞请求处理直到有worker空了。

 

数据传递（令牌）

经典地使用Channel进行任务编排的题：有四个 goroutine，编号为 1、2、3、4。每秒钟会有一个 goroutine 打印出它自己的编号，要求你编写一个程序，让输出的编号总是按照 1、2、3、4、1、2、3、4、……的顺序打印出来。
为了实现顺序的数据传递，定义一个令牌的变量，谁得到令牌，谁就可以打印一次自己的编号，同时将令牌传递给下一个 goroutine。

package main

import (
   "fmt"
   "time"
)

type Token struct{}

func newWorker(id int, ch chan Token, nextCh chan Token) {
   for {
      token := <-ch         // 取得令牌
      fmt.Println(id + 1) // 打印id
      time.Sleep(time.Second)
      nextCh <- token
   }
}

func main() {
   chs := []chan Token{make(chan Token), make(chan Token), make(chan Token), make(chan Token)}

   // 创建4个worker即启动4个协程分别去读1个channel
   for i := 0; i < 4; i++ {
      go newWorker(i, chs[i], chs[(i+1)%4])
   }

   //首先把令牌交给第一个worker
   chs[0] <- Token{}

   select {}
}

运行结果

1                                                                               
2                                                                               
3                                                                               
4                                                                               
1                                                                               
2                                                                               
3                                                                               
4                                                                               
1                                                                               
2

定义一个令牌类型（Token）。
定义创建worker的函数（从自己的chan中读取令牌）。哪个goroutine取得了令牌，就可以打印出自己的编号。因为需要每秒打印一次数据，所以休眠1秒后，再把令牌交给它的下家。
在第24行启动每个worker的goroutine，并在第28行将令牌先交给第一个worker。

信号通知（程序优雅退出）

func main() {
  go func() {
      ...... // 执行业务处理
  }()

  // 处理CTRL+C等中断信号
  termChan := make(chan os.Signal)
  signal.Notify(termChan, syscall.SIGINT, syscall.SIGTERM)
  <-termChan

  // 执行退出之前的清理动作
  doCleanup()
  
  fmt.Println("优雅退出")
}

doCleanup可能是一个很耗时的操作，例如十几分钟才能完成。如果程序退出需要等待这么长时间，那么用户是不能接受的。所以，设置一个最长的等待时间。只要超过了这个时间，程序就不再等待，可以直接退出。所以，退出的时候分为两个阶段：closing代表程序退出，但是清理工作还没做；closed，代表清理工作已经做完。

func main() {
    var closing = make(chan struct{})
    var closed = make(chan struct{})

    go func() {
        // 模拟业务处理
        for {
            select {
            case <-closing:
                return
            default:
                // ....... 业务计算
                time.Sleep(100 * time.Millisecond)
            }
        }
    }()

    // 处理CTRL+C等中断信号
    termChan := make(chan os.Signal)
    signal.Notify(termChan, syscall.SIGINT, syscall.SIGTERM)
    <-termChan

      // 停止业务处理
    close(closing)
    // 执行退出之前的清理动作
    go doCleanup(closed)

    select {
    case <-closed:
    case <-time.After(time.Second):
        fmt.Println("清理超时，不等了")
    }
    fmt.Println("优雅退出")
}

func doCleanup(closed chan struct{}) {
    time.Sleep((time.Minute))
    close(closed)
}