1、创建两个goroutine，以并发的形式分别显示大写和小写字母

  1. // 该程序展示如何创建 goroutine ，以及调度器的行为
  2. package main
  4. import (
  5.     "fmt"
  6.     "runtime"
  7.     "sync"
  8. )
  10. func main() {
  11.     // 分配一个逻辑处理器给调度器使用
  12.     runtime.GOMAXPROCS(1)
  14.     // wg 用来等待程序完成
  15.     // 计数加2，表示要等待两个 goroutine
  16.     var wg sync.WaitGroup
  17.     wg.Add(2)
  19.     fmt.Println("Start Groutine")
  21.     // 声明一个匿名函数，并创建一个 goroutine
  22.     go func() {
  23.         // 在函数退出时调用Done来通知main函数工作已经完成
  24.         defer wg.Done()
  26.         // 显示字母表3次
  27.         for i := 0; i < 3; i++ {
  28.             for char := 'a'; char < 'a'+26; char++ {
  29.                 fmt.Printf("%c ", char)
  30.             }
  31.             fmt.Println()
  32.         }
  33.     }()
  35.     // 声明一个匿名函数，并创建一个 goroutine
  36.     go func() {
  37.         // 在函数退出时调用Done来通知main函数工作已经完成
  38.         defer wg.Done()
  40.         // 显示字母表3次
  41.         for i := 0; i < 3; i++ {
  42.             for char := 'A'; char < 'A'+26; char++ {
  43.                 fmt.Printf("%c ", char)
  44.             }
  45.             fmt.Println()
  46.         }
  47.     }()
  49.     // 等待 goroutine 结束
  50.     fmt.Println("Waiting To Finish")
  51.     wg.Wait()
  53.     fmt.Println("Terminating Program")
  54. }
  56. /*
  57. Start Groutine
  58. Waiting To Finish
  59. A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
  60. A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
  61. A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
  62. a b c d e f g h i j k l m n o p q r s t u v w x y z
  63. a b c d e f g h i j k l m n o p q r s t u v w x y z
  64. a b c d e f g h i j k l m n o p q r s t u v w x y z
  65. Terminating Program
  66. */

2、goroutine 并发求素数

  1. // 求素数
  2. // 该程序展示 goroutine 调度器是如何在单个线程上切分时间片的
  3. package main
  5. import (
  6.     "fmt"
  7.     "runtime"
  8.     "sync"
  9. )
  11. // wg 用来等待程序完成
  12. var wg sync.WaitGroup
  14. func main() {
  15.     // 分配一个逻辑处理器给调度器使用
  16.     runtime.GOMAXPROCS(1)
  17.     // 计数加2，表示要等待两个 goroutine
  18.     wg.Add(2)
  20.     // 创建两个 goroutine
  21.     fmt.Println("Create Goroutine")
  22.     go printPrime("A")
  23.     go printPrime("B")
  25.     // 等待 goroutine 结束
  26.     fmt.Println("Waiting To Finish")
  27.     wg.Wait()
  29.     fmt.Println("Terminating Program")
  30. }
  32. // printPrime 显示5000以内的素数
  33. func printPrime(prefix string) {
  34.     // 在函数退出时调用Done来通知main函数工作已经完成
  35.     defer wg.Done()
  36. next:
  37.     for outer := 2; outer < 5000; outer++ {
  38.         for inner := 2; inner < outer; inner++ {
  39.             if outer%inner == 0 {
  40.                 continue next
  41.             }
  42.         }
  43.         fmt.Printf("%s: %d \n", prefix, outer)
  44.     }
  45.     fmt.Println("Completed", prefix)
  46. }

3、协程并行 + 并发(设置两个逻辑处理器给调度器使用)

  1. // 并行 + 并发
  2. // 该程序展示如何创建 goroutine ，以及调度器的行为
  3. package main
  5. import (
  6.     "fmt"
  7.     "runtime"
  8.     "sync"
  9.     "time"
  10. )
  12. func main() {
  13.     // 分配 2 个逻辑处理器给调度器使用
  14.     runtime.GOMAXPROCS(2)
  16.     // wg 用来等待程序完成
  17.     // 计数加2，表示要等待两个 goroutine
  18.     var wg sync.WaitGroup
  19.     wg.Add(2)
  21.     fmt.Println("Start Groutine")
  23.     // 声明一个匿名函数，并创建一个 goroutine
  24.     go func() {
  25.         // 在函数退出时调用Done来通知main函数工作已经完成
  26.         defer wg.Done()
  28.         // 显示字母表3次
  29.         for i := 0; i < 3; i++ {
  30.             for char := 'a'; char < 'a'+26; char++ {
  31.                 fmt.Printf("%c ", char)
  32.                 time.Sleep(time.Millisecond * 10)
  33.             }
  34.         }
  35.     }()
  37.     // 声明一个匿名函数，并创建一个 goroutine
  38.     go func() {
  39.         // 在函数退出时调用Done来通知main函数工作已经完成
  40.         defer wg.Done()
  42.         // 显示字母表3次
  43.         for i := 0; i < 3; i++ {
  44.             for char := 'A'; char < 'A'+26; char++ {
  45.                 fmt.Printf("%c ", char)
  46.             }
  47.         }
  48.     }()
  50.     // 等待 goroutine 结束
  51.     fmt.Println("Waiting To Finish")
  52.     wg.Wait()
  54.     fmt.Println("\nTerminating Program")
  55. }
  57. // 两个协程，时分复用，时间切片，交替执行
  58. /*
  59. Start Groutine
  60. Waiting To Finish
  61. a A B C D E F G H I J K L M N O P Q R S T U V W X Y Z A B C D E F G H I J K L M N O P Q R S T U V W X Y Z A B C D E F G H I J K L
  62. M N O P Q R S T U V W X Y Z b c d e f g h i j k l m n o p q r s t u v w x y z a b c d e f g h i j k l m n o p q r s t u v w x y z
  63. a b c d e f g h i j k l m n o p q r s t u v w x y z
  64. Terminating Program
  65. */

4、协程竞争状态

  1. // 该程序展示竞争状态（实际中不希望出现这种状态）
  2. package main
  4. import (
  5.     "fmt"
  6.     "runtime"
  7.     "sync"
  8. )
  10. var (
  11.     // counter 是所有 goroutine 都要增加其值的变量
  12.     counter int
  13.     // wg 用来等待程序结束
  14.     wg sync.WaitGroup
  15. )
  17. func main() {
  18.     wg.Add(2)
  20.     go incCounter(1)
  21.     go incCounter(2)
  23.     wg.Wait()
  24.     fmt.Println("Final Counter:", counter)
  26. }
  28. // incCounter 增加报里 counter 变量的值
  29. func incCounter(id int) {
  30.     defer wg.Done()
  32.     for i := 0; i < 2; i++ {
  33.         // 捕获 counter 的值
  34.         value := counter
  36.         // 当前 goroutine 从线程退出，并放回到队列
  37.         runtime.Gosched()
  39.         // 增加本地 value 的值， 并将值保存回 counter
  40.         value++
  41.         counter = value
  43.     }
  44. }
  46. // Final Counter: 2
  1. go build -race // 用竞争检测器标志来编译程序
  2. ./main.exe // 运行程序
  5. PS D:\go-project\src\go_code\channel\channel09\main> go build -race
  6. PS D:\go-project\src\go_code\channel\channel09\main> .\main.exe
  7. ==================
  8. WARNING: DATA RACE
  9. Read at 0x000000a29390 by goroutine 8:
  10.   main.incCounter()
  11.       D:/go-project/src/go_code/channel/channel09/main/main.go:34 +0x8d
  12.   main.main·dwrap·2()
  13.       D:/go-project/src/go_code/channel/channel09/main/main.go:21 +0x39
  15. Previous write at 0x000000a29390 by goroutine 7:
  16.   main.incCounter()
  17.       D:/go-project/src/go_code/channel/channel09/main/main.go:41 +0xaa
  18.   main.main·dwrap·1()
  19.       D:/go-project/src/go_code/channel/channel09/main/main.go:20 +0x39
  21. Goroutine 8 (running) created at:
  22.   main.main()
  23.       D:/go-project/src/go_code/channel/channel09/main/main.go:21 +0xbc
  25. Goroutine 7 (finished) created at:
  26.   main.main()
  27.       D:/go-project/src/go_code/channel/channel09/main/main.go:20 +0x7a
  28. ==================
  29. Final Counter: 4
  30. Found 1 data race(s)
  31. PS D:\go-project\src\go_code\channel\channel09\main>

5、消除竞争状态方法

5.1 锁住共享资源

对共享资源加锁，atomic 和 sync 包里的函数提供了很好的解决方案

  1. 原子函数能够以很底层的加锁机制来同步访问整形变量和指针。 ```go // atomic 包 原子函数加锁 package main

import ( “fmt” “runtime” “sync” “sync/atomic” )

var ( // counter 是所有 goroutine 都要增加其值的变量 counter int64 // wg 用来等待程序结束 wg sync.WaitGroup )

func main() { wg.Add(2)

  1. go incCounter(1)
  2. go incCounter(2)
  4. wg.Wait()
  6. fmt.Println("Final Counter:", counter)

}

// incCounter 增加报里 counter 变量的值 func incCounter(id int) { defer wg.Done()

  1. for i := 0; i < 2; i++ {
  2.     // 安全的对 counter + 1
  3.     // AddInt64() 同步整型值的加法
  4.     atomic.AddInt64(&counter, 1)
  6.     // 当前 goroutine 从线程退出，并放回到队列
  7.     runtime.Gosched()
  8. }

}

// Final Counter: 4

  2. 2. 互斥锁（mutual exclusion, mutex）
  4. 互斥锁用于在代码上创建一个临界区，保证同一时间只有一个 goroutine 可以执行临界区的代码。
  5. ```go
  6. // 互斥锁定义同步访问资源的代码临界区
  7. package main
  9. import (
  10.     "fmt"
  11.     "runtime"
  12.     "sync"
  13. )
  15. var (
  16.     // counter 是所有 goroutine 都要增加其值的变量
  17.     counter int
  18.     // wg 用来等待程序结束
  19.     wg sync.WaitGroup
  20.     // mutex 用来定义一段代码临界区, (加锁、解锁)
  21.     mutex sync.Mutex
  22. )
  24. func main() {
  25.     wg.Add(2)
  27.     go incCounter(1)
  28.     go incCounter(2)
  30.     wg.Wait()
  32.     fmt.Println("Final Counter:", counter)
  33. }
  35. // incCounter 增加报里 counter 变量的值
  36. func incCounter(id int) {
  37.     defer wg.Done()
  39.     for i := 0; i < 2; i++ {
  40.         // 同一时刻，只能允许一个 goroutine 进入这个临界区
  41.         mutex.Lock()
  42.         {
  43.             // 捕获 counter 的值
  44.             value := counter
  46.             // 当前 goroutine 从线程退出，并放回到队列
  47.             runtime.Gosched()
  49.             // 增加本地 value 的值， 并将值保存回 counter
  50.             value++
  51.             counter = value
  52.         }
  53.         // 释放锁，允许其它正在等待的 goroutine 进入临界区
  54.         mutex.Unlock()
  55.     }
  56. }
  58. // Final Counter: 4

5.2 通道 channel

在 Go 语言里，你不仅可以使用原子函数和互斥锁来保证对共享资源的安全访问以及消除竞争状态，还可以使用通道，通过发送和接收需要共享的资源，在 goroutine 之间做同步

  1. // 无缓冲的整形通道
  2. unbuffered := make(chan int)
  4. // 有缓冲的字符串通道
  5. buffered := make(chan string, 10)
  1. // goroutine + channel 用共享的方式，消除竞争状态
  2. package main
  4. import (
  5.     "fmt"
  6.     "runtime"
  7.     "sync"
  8. )
  10. var (
  11.     // counter 是所有 goroutine 都要增加其值的变量
  12.     counter chan int = make(chan int, 1) // 缓冲1个数据的通道，goroutine 更新其值
  13.     // wg 用来等待程序结束
  14.     wg sync.WaitGroup
  15. )
  17. func main() {
  18.     wg.Add(2)
  20.     go incCounter(1)
  21.     go incCounter(2)
  23.     counter <- 0
  25.     wg.Wait()
  26.     close(counter)
  27.     for v := range counter {
  28.         fmt.Println("Final Counter:=", v)
  29.     }
  30.     fmt.Println("Final Counter:", counter)
  31. }
  33. // incCounter 增加报里 counter 变量的值
  34. func incCounter(id int) {
  35.     defer wg.Done()
  37.     for i := 0; i < 2; i++ {
  39.         // 从通道取值 counter 的值
  40.         value, ok := <-counter
  41.         if !ok {
  42.             fmt.Println("err")
  43.             return
  44.         }
  46.         // 当前 goroutine 从线程退出，并放回到队列
  47.         runtime.Gosched()
  49.         // 增加本地 value 的值， 写入 通道 counter
  50.         value++
  51.         counter <- value
  52.     }
  53. }
  55. // Final Counter:= 4
  56. // Final Counter: 0xc00001a0e0

6、无缓冲的通道模拟网球比赛

  1. // 无缓冲的通道模拟网球比赛
  2. package main
  4. import (
  5.     "fmt"
  6.     "math/rand"
  7.     "sync"
  8.     "time"
  9. )
  11. var (
  12.     // wg 用来等待程序结束
  13.     wg sync.WaitGroup
  14. )
  16. func init() {
  17.     rand.Seed(time.Now().UnixNano())
  18. }
  20. func main() {
  21.     // 创建一个无缓冲的通道
  22.     court := make(chan int)
  24.     wg.Add(2)
  26.     // 启动两个选手
  27.     go player("Nadal", court)
  28.     go player("Dav", court)
  30.     // 发球
  31.     court <- 1
  33.     // 等待游戏结束
  34.     wg.Wait()
  35. }
  37. func player(name string, court chan int) {
  38.     defer wg.Done()
  40.     for {
  41.         // 等待球被击打过来
  42.         ball, ok := <-court
  43.         if !ok {
  44.             // 如果通道被关闭，我们就赢了
  45.             fmt.Printf("Player %s Won \n", name)
  46.             return
  47.         }
  49.         // 选随机数，然后用这个数来判断我们是否丢球
  50.         n := rand.Intn(100)
  51.         if n%13 == 0 {
  52.             fmt.Printf("Player %s Missed❗ \n", name)
  54.             // 关闭通道，表示输了
  55.             close(court)
  56.             return
  57.         }
  59.         // 显示击球数，并将击球数 +1
  60.         fmt.Printf("Player %s Hit %d \n", name, ball)
  61.         ball++
  63.         // 将球击向对手
  64.         court <- ball
  65.     }
  66. }
  68. /*
  69. Player Dav Hit 1
  70. Player Nadal Hit 2
  71. Player Dav Missed❗
  72. Player Nadal Won
  73. */

7、无缓冲的通道模拟4个 goroutine 间的接力比赛

  1. // 无缓冲的通道模拟4个 goroutine 间的接力比赛
  2. package main
  4. import (
  5.     "fmt"
  6.     "sync"
  7.     "time"
  8. )
  10. var (
  11.     // wg 用来等待程序结束
  12.     wg sync.WaitGroup
  13. )
  15. func main() {
  16.     // 创建一个无缓冲的通道
  17.     baton := make(chan int)
  19.     // 为最后一位跑步者将计数 +1
  20.     wg.Add(1)
  22.     // 第一位跑步者持有接力棒
  23.     go Runner(baton)
  25.     // 开始比赛
  26.     baton <- 1
  28.     // 等待游戏结束
  29.     wg.Wait()
  30. }
  32. func Runner(baton chan int) {
  33.     var newRunner int
  35.     // 等待接力棒
  36.     runner := <-baton
  38.     // 开始跑
  39.     fmt.Printf("Runner %d Running Width Baton \n", runner)
  41.     // 创建下一位跑步者
  42.     if runner != 4 {
  43.         newRunner = runner + 1
  44.         fmt.Printf("Runner %d To The Line🏃‍♂️ \n", newRunner)
  45.         go Runner(baton)
  46.     }
  48.     // 围绕跑道跑
  50.     time.Sleep(100 * time.Microsecond)
  52.     // 比赛结束了吗？
  53.     if runner == 4 {
  54.         fmt.Printf("Runner %d Finished, Race Over🎈\n", runner)
  55.         wg.Done()
  56.         return
  57.     }
  59.     // 将接力棒交给下一位跑步者
  60.     fmt.Printf("Runner %d Exchange Width Runner %d👉 \n", runner, newRunner)
  61.     baton <- newRunner
  62. }
  64. /*
  65. Runner 1 Running Width Baton
  66. Runner 2 To The Line🏃‍♂️
  67. Runner 1 Exchange Width Runner 2👉
  68. Runner 2 Running Width Baton
  69. Runner 3 To The Line🏃‍♂️
  70. Runner 2 Exchange Width Runner 3👉
  71. Runner 3 Running Width Baton
  72. Runner 4 To The Line🏃‍♂️
  73. Runner 3 Exchange Width Runner 4👉
  74. Runner 4 Running Width Baton
  75. Runner 4 Finished, Race Over🎈
  76. */

8、固定数目的有缓冲的通道

  1. // 有缓冲的通道 固定数目
  2. package main
  4. import (
  5.     "fmt"
  6.     "math/rand"
  7.     "sync"
  8.     "time"
  9. )
  11. const (
  12.     numberGoroutines = 4  // 要使用的 goroutine 的数量
  13.     taskLoad         = 10 // 要处理的工作的数量
  14. )
  16. var (
  17.     // wg 用来等待程序结束
  18.     wg sync.WaitGroup
  19. )
  21. func init() {
  22.     rand.Seed(time.Now().UnixNano())
  23. }
  25. func main() {
  26.     // 创建一个有缓冲的通道来管理工作
  27.     tasks := make(chan string, taskLoad)
  29.     // 启动 goroutine 来处理工作
  30.     wg.Add(numberGoroutines)
  31.     for gr := 0; gr < numberGoroutines; gr++ {
  32.         go worker(tasks, gr)
  33.     }
  35.     // 增加一组要完成的工作
  36.     for post := 1; post <= taskLoad; post++ {
  37.         tasks <- fmt.Sprintf("Task : %d", post)
  38.     }
  40.     // 当所有工作都处理完时关闭通道
  41.     // 以便所有的 goroutine 退出
  42.     close(tasks)
  44.     // 等待所有工作完成
  45.     wg.Wait()
  46. }
  48. func worker(tasks chan string, worker int) {
  49.     defer wg.Done()
  51.     for {
  52.         // 等待分配工作
  53.         task, ok := <-tasks
  54.         if !ok {
  55.             // 意味着通道已经空了，并且已被关闭
  56.             fmt.Printf("Worker: %d : Shutting Down✔ \n", worker)
  57.             return
  58.         }
  60.         // 显示我们开始工作了
  61.         fmt.Printf("Worker: %d : Started %s \n", worker, task)
  63.         // 随机等一段时间来模拟工作
  64.         sleep := rand.Int63n(100)
  65.         time.Sleep(time.Duration(sleep) * time.Millisecond)
  67.         // 显示我们完成了工作
  68.         fmt.Printf("Worker: %d : Completed %s \n", worker, task)
  69.     }
  70. }
  72. /*
  73. Worker: 3 : Started Task : 1
  74. Worker: 1 : Started Task : 2
  75. Worker: 0 : Started Task : 3
  76. Worker: 2 : Started Task : 4
  77. Worker: 3 : Completed Task : 1
  78. Worker: 3 : Started Task : 5
  79. Worker: 0 : Completed Task : 3
  80. Worker: 0 : Started Task : 6
  81. Worker: 1 : Completed Task : 2
  82. Worker: 1 : Started Task : 7
  83. Worker: 2 : Completed Task : 4
  84. Worker: 2 : Started Task : 8
  85. Worker: 2 : Completed Task : 8
  86. Worker: 2 : Started Task : 9
  87. Worker: 1 : Completed Task : 7
  88. Worker: 1 : Started Task : 10
  89. Worker: 2 : Completed Task : 9
  90. Worker: 2 : Shutting Down✔
  91. Worker: 1 : Completed Task : 10
  92. Worker: 1 : Shutting Down✔
  93. Worker: 3 : Completed Task : 5
  94. Worker: 3 : Shutting Down✔
  95. Worker: 0 : Completed Task : 6
  96. Worker: 0 : Shutting Down✔
  97. */