1、任务编排

1、有一道经典的使用 Channel 进行任务编排的题，你可以尝试做一下：有四个 goroutine，编号为 1、2、3、4。每秒钟会有一个 goroutine 打印出它自己的编号，要求你编写一个程序，让输出的编号总是按照 1、2、3、4、1、2、3、4、……的顺序打印出来。

  • 双向通道可以赋值给单向通道，但是单向通道不能赋值给双向通道，不同方向的单向通道也不能互相赋值
  • select {} 会阻塞主协程等待子协程

image.png

  1. // 解法1
  2. package main
  3. import (
  4.     "fmt"
  5.     "time"
  6. )
  8. func main() {
  9.     ch := make(chan int, 4)
  10.     for {
  11.         for i := 1; i < 5; i++ {
  12.             ch <- i
  13.             go func() {
  14.                 st := <-ch
  15.                 fmt.Println(st)
  16.             }()
  17.             time.Sleep(1 * time.Second)
  18.         }
  19.     }
  20. }
  22. // 解法2
  23. package main
  24. import (
  25.     "fmt"
  26.     "sync"
  27.     "time"
  28. )
  30. var (
  31.     c1 = make(chan int, 1)
  32.     c2 = make(chan int, 1)
  33.     c3 = make(chan int, 1)
  34.     c4 = make(chan int, 1)
  35. )
  37. func main() {
  38.     var wg sync.WaitGroup
  39.     wg.Add(4)
  40.     c4 <- 1
  41.     go func() { //1
  42.         for {
  43.             time.Sleep(time.Second)
  44.             <-c4
  45.             fmt.Print(1, " ")
  46.             c1 <- 1
  47.         }
  48.         wg.Done()
  49.     }()
  50.     go func() { //2
  51.         for {
  52.             time.Sleep(time.Second)
  53.             <-c1
  54.             fmt.Print(2, " ")
  55.             c2 <- 2
  56.         }
  57.         wg.Done()
  58.     }()
  59.     go func() { //3
  60.         for {
  61.             time.Sleep(time.Second)
  62.             <-c2
  63.             fmt.Print(3, " ")
  64.             c3 <- 3
  65.         }
  66.         wg.Done()
  67.     }()
  68.     go func() { //4
  69.         for {
  70.             time.Sleep(time.Second)
  71.             <-c3
  72.             fmt.Print(4, " ")
  73.             c4 <- 4
  74.         }
  75.         wg.Done()
  76.     }()
  77.     wg.Wait()
  78. }
  80. // 解法3
  81. package main
  82. import (
  83.     "fmt"
  84.     "time"
  85. )
  87. func main() {
  88.     chArr := [4]chan struct{}{
  89.         make(chan struct{}),
  90.         make(chan struct{}),
  91.         make(chan struct{}),
  92.         make(chan struct{}),
  93.     }
  95.     for i := 0; i < 4; i++ {
  96.         go func(i int) {
  97.             for {
  98.                 <-chArr[i%4]
  99.                 fmt.Printf("i am %d\n", i)
  101.                 time.Sleep(1 * time.Second)
  102.                 chArr[(i+1)%4] <- struct{}{}
  103.             }
  104.         }(i)
  105.     }
  107.     chArr[0] <- struct{}{}
  108.     select {}
  109. }