1 goroutine退出

1.1 超时退出

  1. func main() {
  2.     var wg sync.WaitGroup
  3.     quit := time.Tick(time.Second * 2) // 给个定时器
  5.     wg.Add(1)
  6.     go func() {
  7.         defer wg.Done()
  8.         <-quit
  9.         fmt.Println("over goroutine")
  10.         return
  11.     }()
  12.     wg.Wait()
  14.     fmt.Println("over all")
  15. }

2 context 通知退出

  1. func main() {
  2.     var wg sync.WaitGroup
  3.     ctx, cancel := context.WithTimeout(context.Background(), time.Second*2)
  4.     defer cancel()
  6.     wg.Add(1)
  7.     go func() {
  8.         defer wg.Done()
  9.         <-ctx.Done()
  10.         fmt.Println("over goroutine")
  11.         return
  12.     }()
  13.     wg.Wait()
  15.     fmt.Println("over all")
  16. }

1. 2 外部被动退出：

  1. func main() {
  2.    var wg sync.WaitGroup
  3.     wg.Add(1)
  4.     go func() {
  5.         defer wg.Done()
  6.         ch := make(chan os.Signal)
  7.         signal.Notify(ch, syscall.SIGINT, syscall.SIGTERM)
  8.         <-ch
  9.         fmt.Println("over")
  10.         return
  11.     }()
  12.     wg.Wait()
  13. }

通过两个 goroutine 来计算数字之和，在 goroutine 完成计算后，它会计算两个结果的和：


  1. package main
  3. import "fmt"
  5. func sum(s []int, c chan int) {
  6.         sum := 0
  7.         for _, v := range s {
  8.                 sum += v
  9.         }
  10.         c <- sum // 把 sum 发送到通道 c
  11. }
  13. func main() {
  14.         s := []int{7, 2, 8, -9, 4, 0}
  16.         c := make(chan int)
  17.         go sum(s[:len(s)/2], c)
  18.         go sum(s[len(s)/2:], c)
  19.         x, y := <-c, <-c // 从通道 c 中接收
  21.         fmt.Println(x, y, x+y)
  22. }

使用channel 计算fibonacci数


  1. package main
  3. import (
  4.         "fmt"
  5. )
  7. func fibonacci(n int, c chan int) {
  8.         x, y := 0, 1
  9.         for i := 0; i < n; i++ {
  10.                 c <- x
  11.                 x, y = y, x+y
  12.         }
  13.         close(c)
  14. }
  16. func main() {
  17.         c := make(chan int, 10)
  18.         go fibonacci(cap(c), c)
  19.         // range 函数遍历每个从通道接收到的数据，因为 c 在发送完 10 个
  20.         // 数据之后就关闭了通道，所以这里我们 range 函数在接收到 10 个数据
  21.         // 之后就结束了。如果上面的 c 通道不关闭，那么 range 函数就不
  22.         // 会结束，从而在接收第 11 个数据的时候就阻塞了。
  23.         for i := range c {
  24.                 fmt.Println(i)
  25.         }
  26. }

借助channel完成消息的完整传递

  1. package main
  2. import (
  3.     "fmt"
  4.     "time"
  5. )
  6. func say(s string) {
  7.     for i := 0; i < 5; i++ {
  8.         time.Sleep(100 * time.Millisecond)
  9.         fmt.Println(s, (i+1)*100)
  10.     }
  11. }
  12. func say2(s string) {
  13.     for i := 0; i < 5; i++ {
  14.         time.Sleep(150 * time.Millisecond)
  15.         fmt.Println(s, (i+1)*150)
  16.     }
  17. }
  18. func main() {
  19.     go say2("world")
  20.     say("hello")
  21. }

say2 只执行了 3 次，而不是设想的 5 次
在 goroutine 还没来得及跑完 5 次的时候，主函数已经退出了。

改进

引入一个信道，默认的，信道的存消息和取消息都是阻塞的，在 goroutine 中执行完成后给信道一个值 0，则主函数会一直等待信道中的值，一旦信道有值，主函数才会结束。

  1. package main
  3. import (
  4.     "fmt"
  5.     "time"
  6. )
  8. func say(s string) {
  9.     for i := 0; i < 5; i++ {
  10.         time.Sleep(100 * time.Millisecond)
  11.         fmt.Println(s, (i+1)*100)
  12.     }
  13. }
  14. func say2(s string, ch chan int) {
  15.     for i := 0; i < 5; i++ {
  16.         time.Sleep(150 * time.Millisecond)
  17.         fmt.Println(s, (i+1)*150)
  18.     }
  19.     ch <- 0
  20.     close(ch)
  21. }
  23. func main() {
  24.     ch := make(chan int)
  25.     go say2("world", ch)
  26.     say("hello")
  27.     fmt.Println(<-ch)
  28. }

使用channel将异步变为同步

**

  1. package main
  3. import (
  4.     "fmt"
  5.     "time"
  6. )
  8. var ch = make(chan int)
  10. func main() {
  11.     for i := 1; i <= 75; i++ {
  12.         go print(i)
  13.         ch <- 0
  14.     }
  15.     time.Sleep(5 * time.Second) //wait all goroutines
  16. }
  18. func print(i int) {
  19.     <-ch
  20.     fmt.Println(i)
  21. }

主协程如何等其余协程完再操作

sync包和channel来解决协程同步和通讯。


  1. package main
  3. import (
  4.     "fmt"
  5.     "sync"
  6.     "time"
  7. )
  9. var wg sync.WaitGroup //定义一个同步等待的组
  11. func task(i int){
  12.     fmt.Println("task...",i)
  13.     //耗时操作任务，网络请求，读取文件
  14.     time.Sleep(time.Second)
  15.     wg.Done() //减去一个计数
  16. }
  18. func main(){
  19.     for i:= 0;i<10;i++{
  20.         wg.Add(1) //添加一个计数
  21.         go task(i)
  22.     }
  23.     wg.Wait() //阻塞直到所有任务完成
  24.     fmt.Println("over")
  25. }

利用缓冲信道channel协程之间通讯，其阻塞等待功能实现等待一组协程结束，不能保证其goroutine按照顺序执行

  1. package main
  3. import (
  4.     "fmt"
  5. )
  7. var ch = make(chan int,10)
  9. func task(i int){
  10.     fmt.Println("task...",i)
  11.     ch <- i
  12. }
  14. func main(){
  15.     for i:= 0;i<10;i++{
  16.         go task(i)
  17.     }
  18.     for i:= 0;i<10;i++{
  19.         <- ch
  20.     } 
  21.     fmt.Println("over")
  22. }

利用无缓冲的信道channel协程之间通讯，其阻塞等待功能实现等待一组协程结束，保证了其goroutine按照顺序执行

  1. package main
  3. import (
  4.     "fmt"
  5.     "time"
  6. )
  8. var ch = make(chan int)
  10. func task(i int){
  11.     fmt.Println("task...",i)
  12.     time.Sleep(time.Second)
  13.      <- ch
  14. }
  16. func main(){
  17.     for i:= 0;i<10;i++{
  18.         go task(i)
  19.         ch <- i
  20.     }
  21.     fmt.Println("over")
  22. }

golang两个协程交替打印1-100的奇数偶数

  1. package main
  3. import (
  4.     "fmt"
  5. )
  7. func main() {
  8.     chan1 := make(chan struct{}, 1)
  9.     chan2 := make(chan struct{}, 1)
  10.     chan_final := make(chan struct{}, 1)
  11.     chan1 <- struct{}{}
  12.     N := 100
  13.     go func(N int) {
  14.         for i := 1; i <= N; i += 2 {
  15.             <-chan1
  16.             fmt.Println(i)
  17.             chan2 <- struct{}{}
  18.         }
  19.     }(N)
  20.     go func(N int) {
  21.         for i := 2; i <= N; i += 2 {
  22.             <-chan2
  23.             fmt.Println(i)
  24.             if i == N {
  25.                 chan_final <- struct{}{}
  26.             }
  27.             chan1 <- struct{}{}
  29.         }
  31.     }(N)
  32.     <-chan_final
  33. }

dog cat fish 按这个输出一百句


  1. package main
  3. import (
  4.     "fmt"
  5.     "sync"
  6. )
  8. //dog cat fish 按这个输出一百句   第一题
  10. var wg sync.WaitGroup
  12. func main() {
  13.     // counter use to count the output
  14.     var counter int = 1000
  15.     dogch := make(chan struct{}, 1)
  16.     catch := make(chan struct{}, 1)
  17.     fishch := make(chan struct{}, 1)
  18.     wg.Add(3)
  19.     // let run the three goroutine
  21.     // the origin of the goroutine to set dogch <- struct {}{}
  22.     dogch <- struct{}{}
  24.     go dog(dogch, counter, catch)
  25.     go cat(catch, counter, fishch)
  26.     go fish(fishch, counter, dogch)
  28.     wg.Wait()
  29. }
  31. func dog(dogch chan struct{}, counter int, catch chan struct{}) {
  32.     dogtimes := 0
  33.     for dogtimes < counter {
  34.         select {
  35.         case <-dogch:
  36.             fmt.Println("dog")
  37.             dogtimes++
  38.             // let cat run
  39.             catch <- struct{}{}
  40.         }
  41.     }
  42.     wg.Done()
  44. }
  46. func cat(catch chan struct{}, counter int, fishch chan struct{}) {
  47.     cattimes := 0
  48.     for cattimes < counter {
  49.         select {
  50.         case <-catch:
  51.             fmt.Println("cat")
  52.             cattimes++
  53.             //let fish run
  54.             fishch <- struct{}{}
  55.         }
  56.     }
  57.     wg.Done()
  58. }
  60. func fish(fishch chan struct{}, counter int, dogch chan struct{}) {
  61.     fishtimes := 0
  62.     for fishtimes < counter {
  63.         select {
  64.         case <-fishch:
  65.             fmt.Println("fish")
  66.             fishtimes++
  67.             // let dog run
  68.             dogch <- struct{}{}
  69.         }
  70.     }
  71.     wg.Done()
  73. }
  75. //题解：
  76. // 分别使用三个goroutine代表dog cat fish，由于携程执行的无顺序性，但是题目要求顺序循环输出，
  77. // 所以，我们使用通道来实现阻塞，通过传值到通道中来实现顺序执行
  78. // 首先定义了三个有缓冲通道 ，并设置了循环的次数counter
  79. // counter use to count the output
  80. //    var counter int = 3
  81. //    dogch := make(chan struct{}, 1)
  82. //    catch := make(chan struct{}, 1)
  83. //    fishch := make(chan struct{}, 1)
  85. // 然后对于每一个goroutine来说设置一个 for循环来执行counter次，里面采用for-select-case
  86. // 如果该通道没值 则会阻塞在这个地方直到有值传进来。
  88. //  // the origin of the goroutine to set dogch <- struct {}{}
  89. //  dogch <- struct{}{} 这一句话是三个goroutin启动的触发条件。
  90. //  第一个goroutine有值之后，执行第一个输出 dog，然后向catch里面传值，这个时候被阻塞的第一个goroutine//
  91. //  得以激活，一次类推，直到把循环走完，每个goroutine都done了，程序结束

一个goroutine生产消息，一个消费消息

  1. func main() {
  2.     ch := make(chan int)
  3.     done := make(chan bool)
  4.     go func() {
  5.         for {
  6.             select {
  7.             case ch <- rand.Intn(5): // Create and send random number into channel
  8.             case <-done: // If receive signal on done channel - Return
  9.                 return
  10.             default:
  11.             }
  12.         }
  13.     }()
  15.     go func() {
  16.         for i := 0; i < 5; i++ {
  17.             fmt.Println("Rand Number = ", <-ch) // Print number received on standard output
  18.         }
  19.         done <- true // Send Terminate Signal and return
  20.         return
  21.     }()
  22.     <-done // Exit Main when Terminate Signal received
  23. }

笔试题参考

https://www.zhihu.com/column/interview 以及这个人的知乎其他文章