简介

使用goroutine和channel实现gin的并发前，先认识下goroutine和channel，特别的简单，以下几个示例就可以完全掌握这个轻量级内置功能的应用

Goroutine

通过go关键字执行goroutine, 在main函数中创建了一个新的 goroutine 来执行timesThree函数并继续执行下一条指令。因此，fmt.Println(“Done!”)在 goroutine 之前执行

  1. package main
  3. import (
  4.     "fmt"
  5.     "time"
  6. )
  8. /*
  9.  * Goroutine和channels实现并发
  10.  *
  11.  *
  12.  *
  13.  */
  15.  /// @dev 定义一个mul时间的计数器
  16. func timesThree(number int) {
  17.     fmt.Println(number * 3)
  18. }
  20. func main() {
  21.     fmt.Println("We are executing a goroutine")
  22.     g
  23.     fmt.Println("Done !")
  24.     time.Sleep(time.Second)
  25. }
  27. 分别输出：
  28.   We are executing a goroutine    
  29.   Done!
  30.   9
  31.   Process finished with the exit code 0

Channel

通过初始化channel可以实现把参数丢进channel里进行传输，通过<-取值和存值
*注：channel需要不断的接收和取值，类似于队列，需要make关键字创建一个内存

  1. package main
  3. import (
  4.     "fmt"
  5. )
  7. /*
  8.  * Goroutine和channels实现并发
  9.  *
  10.  *
  11.  *
  12.  */
  14. /// @dev 定义一个mul时间的计数器
  15. func timesThree(number int, ch chan int) {
  16.     result := number * 3
  17.     fmt.Println(result)
  19.     // 把结果丢到channel里
  20.     ch <- result
  21. }
  23. func main() {
  24.     fmt.Println("We are executing a goroutine")
  26.     //channel创建时要新建内存，记得加make
  27.     ch := make(chan int)
  28.     go timesThree(3, ch)
  30.     //从channel中取回计算的值
  31.     result := <-ch
  33.     fmt.Printf("The result is: %v", result)
  34. }
  36. 分别输出：
  37.   We are executing a goroutine
  38.   9
  39.   The result is: 9
  40.   Process finished with the exit code 0

缓冲Channel

有时候goroutine执行完成后，需要返回多个值，所以需要一个缓冲Channel去接收

  1. package main
  3. import (
  4.     "fmt"
  5.     "time"
  6. )
  8. /*
  9.  * Goroutine和channels实现并发
  10.  *
  11.  *
  12.  *
  13.  */
  15. /// @dev 定义一个mul时间的计数器
  16. func timesThree(arr []int, ch chan int) {
  17.     for _, elem := range arr {
  18.         ch <- elem * 3
  19.     }
  20. }
  22. func main() {
  23.     fmt.Println("We are executing a goroutine")
  24.     arr := []int{2, 3, 4}
  25.     //channel创建时要新建内存，记得加make
  26.     ch := make(chan int)
  27.     go timesThree(arr, ch)
  28.     time.Sleep(time.Second)
  30.     //从channel中取回计算的值
  31.     result := <-ch
  33.     fmt.Printf("The result is: %v", result)
  34. }
  36. 分别输出：
  37.   We are executing a goroutine
  38.   The result is: 6
  39.   Process finished with the exit code 0
  43. package main
  45. import (
  46.     "fmt"
  47. )
  49. /*
  50.  * Goroutine和channels实现并发
  51.  *
  52.  *
  53.  *
  54.  */
  56. /// @dev 定义一个mul时间的计数器
  57. func timesThree(arr []int, ch chan int) {
  58.     for _, elem := range arr {
  59.         ch <- elem * 3
  60.     }
  61. }
  63. func main() {
  64.     fmt.Println("We are executing a goroutine")
  65.     arr := []int{2, 3, 4}
  66.     //channel创建时要新建内存，记得加make
  67.     ch := make(chan int)
  68.     go timesThree(arr, ch)
  69.     //从channel中取回计算的值
  71.   //通过循环长度，获取通道所有的值
  72.     for i := 0; i < len(arr); i++ {
  73.         fmt.Printf("The result is: %v", <-ch)
  74.     }
  75. }

匿名函数作为Goroutine

另一个很棒的特性是可以将匿名函数作为 goroutine 执行，如果我们不重用它的话。请注意，我们在关键字之后声明函数，go并在最后的大括号之后的括号之间传递参数。

  1. package main
  3. import (
  4.     "fmt"
  5. )
  7. /*
  8.  * Goroutine和channels实现并发
  9.  *
  10.  *
  11.  *
  12.  */
  14. func main() {
  15.     fmt.Println("We are executing a goroutine")
  16.     arr := []int{2, 3, 4}
  17.     //创建通道时指定通道的长度，有点像创建静态数组和动态数组的区别
  18.     ch := make(chan int, len(arr))
  19.     go func(arr []int, ch chan int) {
  20.         for _, elem := range arr {
  21.             ch <- elem
  22.         }
  23.     }(arr, ch)
  25.     for i := 0; i < len(arr); i++ {
  26.         fmt.Println("Result: %v \n", <-ch)
  27.     }
  28. }
  31. 分别输出：
  32.   We are executing a goroutine
  33.   Result: %v 
  34.    2
  35.   Result: %v 
  36.    3
  37.   Result: %v 
  38.    4

Goroutine之间的通道

通道不仅用于goroutine和main函数之间的交互，它们还提供了一种在不同goroutine之间进行通信的方式。例如，创建一个函数，将返回的每个结果减去3, timesThree的前提是它是偶数

即使在这种情况下，不必minusThree像 goroutine 一样运行并通过通道返回结果，它也说明了 goroutine 之间的交互是如何工作的。当您在一个解决方案中有两个不同的功能需要高性能并且其中一个的某些条件会影响另一个的结果时，这尤其有用。

  1. package main
  3. import (
  4.     "fmt"
  5. )
  7. /*
  8.  * Goroutine和channels实现并发
  9.  *
  10.  *
  11.  *
  12.  */
  14. func timesThree(arr []int, ch chan int) {
  15.     minusCh := make(chan int, 3)
  16.     for _, elem := range arr {
  17.         value := elem * 3
  18.         if value%2 == 0 {
  19.             go minusThree(value, minusCh)
  20.             value = <-minusCh
  21.         }
  22.         ch <- value
  23.     }
  24. }
  26. func minusThree(number int, ch chan int) {
  27.     ch <- number - 3
  28.     fmt.Println("The functions continues after returning the result")
  29. }
  31. func main() {
  32.     fmt.Println("We are executing a goroutine")
  33.     arr := []int{2, 3, 4}
  35.     //创建通道时指定通道的长度，有点像创建静态数组和动态数组的区别
  36.     ch := make(chan int, len(arr))
  37.     go timesThree(arr, ch)
  38.     for i := 0; i < len(arr); i++ {
  39.         fmt.Printf("Result: %v \n", <-ch)
  40.     }
  41. }
  43. 分别输出：
  44.   We are executing a goroutine
  45.   The functions continues after returning the result
  46.   The functions continues after returning the result
  47.   Result: 3 
  48.   Result: 9 
  49.   Result: 9

Range范围和关闭Channel

使用这些特征可以从goroutine接收连续的元素，直到它关闭通道，使用该指令，for i := range ch 可以从goroutine的结果发送后立即对其进行迭代(可以理解为立刻迭代队列)。一旦完成发送数据接收，close函数可以关闭通道
注：如果使用 for i := range ch 循环通道，没有进行close(ch)关闭通道，程序会崩溃
输出：
*”fatal error: all goroutines are asleep - deadlock!”

  1. package main
  3. import (
  4.     "fmt"
  5. )
  7. /*
  8.  * Goroutine和channels实现并发
  9.  *
  10.  *
  11.  *
  12.  */
  14. func timesThree(arr []int, ch chan int) {
  15.     //调用defer延迟函数，完成接收后关闭通道
  16.     defer close(ch)
  17.     for _, elem := range arr {
  18.         ch <- elem
  19.     }
  20. }
  22. func main() {
  23.     fmt.Println("We are executing a goroutine")
  24.     arr := []int{2, 3, 4}
  26.     //创建通道时指定通道的长度，有点像创建静态数组和动态数组的区别
  27.     ch := make(chan int, len(arr))
  28.     go timesThree(arr, ch)
  29.     for i := range ch {
  30.         fmt.Printf("Result: %v \n", i)
  31.     }
  32. }

select 通道分流控制

我们如何同时从多个通道读取数据？作为一种同时等待多个通道的方式，防止一个通道阻塞另一个通道。

  1. package main
  3. import (
  4.     "fmt"
  5. )
  7. /*
  8.  * Goroutine和channels实现并发
  9.  *
  10.  *
  11.  *
  12.  */
  13. func timesThree(arr []int, ch chan int) {
  14.     for _, elem := range arr {
  15.         ch <- elem * 3
  16.     }
  17. }
  19. func minusThree(arr []int, ch chan int) {
  20.     for _, elem := range arr {
  21.         ch <- elem - 3
  22.     }
  23. }
  25. func main() {
  26.     fmt.Println("We are executing a goroutine")
  27.     arr := []int{2, 3, 4, 5, 6}
  28.     ch := make(chan int, len(arr))
  29.     minusCh := make(chan int, len(arr))
  31.     go timesThree(arr, ch)
  32.     go minusThree(arr, minusCh)
  34.     for i := 0; i < len(arr)*2; i++ {
  35.         select {
  36.         case msg1 := <-ch:
  37.             fmt.Printf("Result timesThree: %v \n", msg1)
  38.         case msg2 := <-minusCh:
  39.             fmt.Printf("Result minusThree: %v \n", msg2)
  40.         default:
  41.             fmt.Println("Non blocking way of listening to multiple channels")
  42.         }
  43.     }
  44. }
  46. 分别输出：
  47.   We are executing a goroutine
  48.   Result minusThree: -1 
  49.   Result timesThree: 6 
  50.   Result minusThree: 0 
  51.   Result timesThree: 9 
  52.   Result timesThree: 12 
  53.   Result timesThree: 15 
  54.   Result minusThree: 1 
  55.   Result timesThree: 18 
  56.   Result minusThree: 2 
  57.   Result minusThree: 3
  58.   Process finished with the exit code 0

sync.Mutex互斥锁

使用并发时可能出现的一个问题是，当两个gshare相同的资源不应该被多个 goroutine 同时访问时。在并发情况下，修改共享资源的代码块称为临界区。

因为 goroutine 会同时访问和重新分配相同的内存空间，所以我们会得到有问题的结果。在这种情况下，n *= 3将是临界区。

我们可以通过使用sync.Mutex. 这可以防止多个 goroutine 同时访问Lock()和Unlock()函数之间的指令。

  3. package main
  5. import (
  6.     "fmt"
  7.     "time"
  8. )
  10. var n = 1
  12. func timesThree() {
  13.     n *= 3
  14.     fmt.Println(n)
  15. }
  17. func main() {
  18.     fmt.Println("We are executing a goroutine")
  19.     for i := 0; i < 10; i++ {
  20.         go timesThree()
  21.     }
  22.     time.Sleep(time.Second)
  23. }
  25. 错误的结果
  26. 分别输出：
  27.   We are executing a goroutine
  28.   27
  29.   81
  30.   3
  31.   9
  32.   243
  33.   6561
  34.   729
  35.   19683
  36.   59049
  37.   2187
  38.   Process finished with the exit code 0
  1. package main
  3. import (
  4.     "fmt"
  5.     "time"
  6. )
  8. var n = 1
  9. var mu sync.Mutex
  11. func timesThree() {
  12.       mu.Lock()
  13.     defer mu.Unlock()
  14.     n *= 3
  15.     fmt.Println(n)
  16. }
  18. func main() {
  19.     fmt.Println("We are executing a goroutine")
  20.     for i := 0; i < 10; i++ {
  21.         go timesThree()
  22.     }
  23.     time.Sleep(time.Second)
  24. }