goroutine 和 channel

goroutine

看一个需求

  1. 要求统计1-20000的数字中，哪些是素数？

    • 分析思路：
      • 传统的方法，就是使用一个循环，循环的判断各个数是不是素数。
      • 使用并发或者并行的方式，将统计素数的任务分配给多个 goroutine 去完成，这时就会使用到 goroutine。

        基本介绍

        进程和线程的说明

  2. 进程就是程序在操作系统中一次执行过程，是系统进行资源分配和调度的基本单位。

  3. 线程是进程的一个执行实例，是程序执行的最小单元，它是比进程更小的能独立运行的基本单位。
  4. 一个进程可以创建销毁多个线程，同一个进程的多个线程可以并发执行。

  5. 一个程序至少有一个进程，一个进程，至少有一个线程。

    并发和并行

  6. 多线程程序在单核上运行，就是并发。

    • 多个任务作用在一个 cpu
    • 从微观的角度看，在一个时间点上，其实只有一个任务在执行。

  7. 多线程程序在多核上运行，就是并行。

    • 多个任务作用在多个cpu
    • 从微观的角度看，在一个时间点上，就是多个任务在同时执行。
    • 这样看来，并行的速度快。

      Go 协程和 Go 主线程

  8. Go 主线程(由程序员直接成为线程/也可以理解为进程)：一个 Go 线程上，可多个协程，你可以这样理解，协程是轻量级的线程。

  9. Go 协程的特点

    • 有独立的栈空间
    • 共享程序堆空间
    • 调度由用户控制
    • 协程是轻量级的线程

      快速入门

  10. 编写一个程序，完成如下功能：

    • 在主线程(可以理解成进程)中，开启一个 goroutine，该协程每隔 1 秒输出 “hello, world!”
    • 在主线程中也每隔一秒输出 “hello,golang”，输出 10 次后，退出程序
    • 要求主线程和 goroutine 同时执行。 ```go package main

import ( “fmt” “strconv” “time” )

/ 案例： (1) 在主线程(可以理解成进程)中，开启一个 goroutine，该协程每隔1秒输出”heello, world!” (2) 在主线程中也每隔一秒输出”hello,golang”，输出10次后，退出程序 (3) 要求主线程和 goroutine 同时执行。 /

//编写一个函数，每隔1秒输出 “hello，world” func test() { for i :=0; i <= 10; i++ { fmt.Println(“test() hello, world “ + strconv.Itoa(i)) time.Sleep(time.Second) } }

func main() {

  1. go test() //开启了一个协程
  3. for i := 0; i <= 10; i++ {
  4.     fmt.Println("main() hello, golang " + strconv.Itoa(i))
  5.     time.Sleep(time.Second)
  6. }

}

  2. 2. 总结 
  3.    - 如果主线程退出了，则协程即使还没有执行完毕，也会退出。 
  4.    - 当然协程也可以在主线程没有退出前，就自己结束了，比如完成了自己的任务。 
  5. 3. 快速入门案例小结 
  6.    - 主线程是一个物理进程，直接作用在 cpu 上的，是重量级的，非常耗费 cpu 资源。 
  7.    - 协程从主线程开启的，是轻量级的线程，是逻辑态。对资源消耗相对小。 
  8.    - Golang 的协程机制是重要的特点，可以轻松的开启上万个协程。其他编程语言的并发机制是一般基于线程的，开启过多线程，资源耗费大，这里就突显 Golang 在并发上的优势了。 
  9. <a name="6853de89"></a>
  10. ### goroutine 的调度模型
  11. <a name="eabb2d63"></a>
  12. #### MPG 模型基本介绍
  14. 1. MPG 模型基本介绍 
  15.    - M: 操作系统的主线程(物理进程) 
  16.    - P: 协程执行需要的上下文 
  17.    - G: 协程 
  18. 2.  MPG 模式运行的状态一 
  19.    - 当前程序有三个 M ，如果三个 M 都在一个 CPU 运行，就是并发，如果在不同的 CPU 运行就是并行。 
  20.    - M1, M2, M3 正在执行一个 G，M1 的协程队列有三个，M2 的协程队列有 3 个，M3 协程队列有 2 个。 
  21.    - Go 的协程是轻量级的线程，是逻辑态的，Go 可以容易的起上万个协程。 
  22.    - 其他程序 C/Java 的多线程，往往是内核态的，比较重量级，几千个线程可能耗光 CPU 
  23. 3. MPG 模式运行的状态二 
  24.    - M0 主线程正在执行 G0 协程，另外有三个协程在队列等待 
  25.    - 如果 G0 协程阻塞，比如读取文件或者数据库等。 
  26.    - 这时就会创建 M1 主线程(也可能是从已有的线程池中取出 M1)，并且将等待的3个协程挂到 M1 下执行，M0 的主线程下的 G0 仍然执行文件 io 的读写。 
  27.    - 这样的 MPG 调度模式，可以既让 G0 执行，同时也不会让队列的其他协程一直堵塞，仍然可以并发/并行执行。 
  28.    - 等到 G0 不再堵塞了，M0 会被放到空闲的主线程继续执行(从已有的线程池中取)，同时 G0 又会被唤醒。 
  29. <a name="d8993da2"></a>
  30. ### 设置 Golang 运行的 CPU 数目
  32. 1. 设置 Golang 运行的 CPU 数目
  33. ```go
  34. package main
  36. import (
  37.     "fmt"
  38.     "runtime"
  39. )
  43. func main() {
  45.     cpuNum := runtime.NumCPU()
  46.     fmt.Println("cpuNum = ", cpuNum)
  48.     //可以自己设置使用多少个 cpu
  49.     runtime.GOMAXPROCS(cpuNum - 2)
  50.     fmt.Println("ok")
  51. }

channel(管道)

看个需求

  1. 需求：现在要计算1-200的各个数的阶乘，并且把各个数的阶乘放入 map 中，最后显示出来。要求使用 goroutine 完成。
  2. 分析思路：
    • 使用 goroutine 来完成，效率高，但是会出现并发/并行安全问题。
    • 这里就提出了不同 goroutine 如何通信的问题
  3. 代码实现
    • 使用 goroutine 来完成
    • 在运行某个程序时，在编译该程序时候，可以使用 go build -race xxx.go ，就会知道是否存在资源竞争问题。
  4. 代码描述 ```go package main

import ( “fmt” “time” )

/ 案例一： 需求：现在要计算1-200的各个数的阶乘，并且把各个数的阶乘放入 map 中，最后显示出来。 要求使用 goroutine 完成。 /

//思路 //1. 编写一个函数，来计算各个数的阶乘，并放入到 map 中。 //2. 我们启动的协程多个，统一的将阶乘的结果放入到 map 中。 //3. map 应该做成一个全局的。

var ( myMap = make(map[int]int, 10) )

// test 函数就是计算 n!，然后将这个结果放入 myMap func test(n int) { res := 1 for i:=1; i<= n; i++ { res *= i }

  1. //这里我们将 res 放入到 myMap 中
  2. myMap[n] = res // fatal error: concurrent map writes -- 此段代码报错

}

func main() { //这里开启多个协程完成任务 for i :=1; i <= 200; i++ { go test(i) }

  1. //休眠 10s
  2. time.Sleep(time.Second * 10)
  4. //输出结果，遍历这个结果
  5. for index, value := range myMap {
  6.     fmt.Printf("map[%d] = %d \n", index, value)
  7. }

}

  1. <a name="4a162c5d"></a>
  2. ### 不同 goroutine 之间如何通讯
  4. 1. 全局变量的互斥锁
  5. 1. 使用管道 channel 来解决
  6. <a name="834b9c09"></a>
  7. ### 使用全局变量加锁同步改进程序
  9. 1. 代码改进
  10. ```go
  11. package main
  13. import (
  14.     "fmt"
  15.     "sync"
  16.     "time"
  17. )
  19. /*
  20.     案例一：
  21.         需求：现在要计算1-200的各个数的阶乘，并且把各个数的阶乘放入 map 中，最后显示出来。
  22.              要求使用 goroutine 完成。
  23. */
  25. /*
  26.     思路:
  27.         1. 编写一个函数，来计算各个数的阶乘，并放入到 map 中。
  28.         2. 我们启动的协程多个，统一的将阶乘的结果放入到 map 中。
  29.         3. map 应该做成一个全局的。
  30. */
  31. var (
  32.     myMap = make(map[int]int, 10)
  33.     //声明一个全局的互斥锁
  34.     //lock 是一个全局的互斥锁
  35.     //sync 是包：syncchornized 同步
  36.     //Mutex : 互斥
  37.     lock sync.Mutex
  38. )
  41. // test 函数就是计算 n!，然后将这个结果放入 myMap
  42. func test(n int) {
  43.     res := 1
  44.     for i:=1; i <= n; i++ {
  45.         res *= i
  46.     }
  48.     //这里我们将 res 放入到 myMap 中
  49.     //加锁
  50.     lock.Lock()
  51.     myMap[n] = res // fatal error: concurrent map writes -- 此段代码报错
  52.     //解锁
  53.     lock.Unlock()
  54. }
  57. func main() {
  58.     //这里开启多个协程完成任务
  59.     for i := 1; i <= 20; i++ {
  60.         go test(i)
  61.     }
  63.     //休眠 10s
  64.     time.Sleep(time.Second * 5)
  66.     //输出结果，遍历这个结果
  67.     lock.Lock()
  68.     for index, value := range myMap {
  69.         fmt.Printf("map[%d] = %d \n", index, value)
  70.     }
  71.     lock.Unlock()
  73. }

基本介绍

为什么需要 channel

  1. 前面使用全局变量加锁同步来解决 goroutine 的通讯，但不完美。
  2. 主线程在等待所有 goroutine 全部完成的时间很难确定，这里我们设置10秒，仅仅是估算。
  3. 如果主线程休眠时间长了，会加长等待时间，如果等待时间短了，可能还有 goroutine 处于工作状态，这是也会随着主线程的退出而销毁。

  4. 通过全局变量加锁同步来实现通讯，也并不利于多个协程对全局变量的读写操作。

    channel 的介绍

  5. channel 本质就是一个数据结构-队列

  6. 数据是先进先出
  7. 线程安全，多 goroutine 访问时，不需要加锁，就是说 channel 本身就是线程安全的。

  8. channel 时有类型，一个 string 的 channel 只能存放 string 类型数据。

    基本使用

    定义/声明变量 channel

  9. 举例

    1. var intChan chan int (intChan 用于存放 int 数据)
    2. var mapChan chan map[int]string (mapChan 用于存放 map[int]string 类型)
    3. var perChan chan Person
    4. var perChan2 chan *Person
    5. ...

  10. 说明

    • channel 是引用类型
    • channel 必须初始化才能写入数据，即 make 后才能使用
    • 管道是有类型的，intChan 只能写入整数 int

  11. channel 初始化 

    1. var intChan chan int
    2. intChan = make(chan int, 10)

  12. channel 写入数据

    1. var intChan chan int
    2. intChan = make(chan int, 10)
    3. num := 999
    4. intChan <- 10
    5. intChan <- num

  13. 快速入门案例 ```go package main

import “fmt”

func main() { //演示一下管道的使用 //1. 创建一个可以存放3个 int 类型的管道 var intChan chan int intChan = make(chan int, 3)

  1. //2. 看看 intChan 是什么
  2. fmt.Printf("intChan 的值 = %v intChan 本身的地址 = %p \n", intChan, &intChan) // 地址
  4. //3. 向管道写入数据
  5. intChan <- 10
  6. num := 211
  7. intChan <- num
  9. //注意点，当给我们给管道写入数据时，不能超过其容量
  10. intChan <- 50
  11. //intChan <- 98 // deadlock!
  13. //4. 看看管道的长度和cap(容量)
  14. fmt.Printf("intChan len = %v cap = %v \n", len(intChan), cap(intChan))
  16. //5. 从管道中读取数据
  17. var num2 int
  18. num2 = <- intChan
  19. fmt.Println("num2 =", num2)
  20. fmt.Printf("intChan len = %v cap = %v \n", len(intChan), cap(intChan))
  22. //6. 在没有使用协程的情况下，如果我们的管道数据已经全部取出，再取就会报告 deadlock!
  23. num3 := <-intChan
  24. num4 := <-intChan
  25. // num5 := <-intChan 报错
  27. fmt.Println("num3 =", num3, "num4 =", num4)

}

  1. <a name="4d62e1f8"></a>
  2. #### channel 使用的注意事项
  4. 1. channel 使用的注意事项 
  5.    - channel 中只能存放指定的数据类型 
  6.    - channel 的数据放满后，就不能再放入了。 
  7.    - 如果从 channel 取出数据后，可以继续放入。 
  8.    - 在没有使用协程的情况下，如果 channel 数据取完了，再取就会报告 dead lock。 
  9. <a name="24f60c15"></a>
  10. #### 案例演示
  12. 1. 案例一
  13. ```go
  14. package main
  16. import "fmt"
  19. func main() {
  20.     var intChan chan int
  21.     intChan = make(chan int, 3)
  22.     intChan <- 10
  23.     intChan <- 20
  24.     intChan <- 10
  25.     //因为 intChan 的容量为3，再存会报告 dead lock！
  26.     //intChan <- 50
  27.     num1 := <- intChan
  28.     num2 := <- intChan
  29.     num3 := <- intChan
  30.     //因为 intChan 这是已经没有数据了，再取就会报告 dead lock
  31.     //num4 := <- intChan
  32.     fmt.Printf("num1 = %v num2 = %v, num3 = %v", num1, num2, num3)
  33. }
  1. 案例二 ```go package main

import “fmt”

func main() { var mapChan chan map[string]string mapChan = make(chan map[string]string, 10) m1 := make(map[string]string, 20) m1[“city1”] = “北京” m1[“city2”] = “天津”

  1. m2 := make(map[string]string, 20)
  2. m2["hero1"] = "宋江"
  3. m2["hero2"] = "武松"
  5. //将数据存放到 mapChan
  6. mapChan <- m1
  7. mapChan <- m2
  9. //取出
  10. m3 := <- mapChan
  11. m4 := <- mapChan
  13. fmt.Printf("mapChan = %v, mapChan = %p \n", mapChan, &mapChan)
  14. fmt.Println(m3, m4)

}

  1. 3.案例三
  2. ```go
  3. package main
  5. import "fmt"
  7. type Cat struct {
  8.     Name string
  9.     Age int
  10. }
  14. func main() {
  15.     var catChan chan Cat
  16.     catChan = make(chan Cat, 10)
  18.     cat1 := Cat{Name: "Tom", Age: 18,}
  19.     cat2 := Cat{Name: "Tom~", Age: 180,}
  21.     catChan <- cat1
  22.     catChan <- cat2
  24.     //取出
  25.     cat11 := <- catChan
  26.     cat22 := <- catChan
  28.     fmt.Println(cat11, cat22)
  29. }
  1. 案例四 ```go package main

import “fmt”

type Cat struct { Name string Age int }

func main() { var catChan chan Cat catChan = make(chan Cat, 10)

  1. cat1 := Cat{Name: "Tom", Age: 18,}
  2. cat2 := Cat{Name: "Tom~", Age: 180,}
  4. catChan <- &cat1
  5. catChan <- &cat2
  7. //取出
  8. cat11 := <- catChan
  9. cat22 := <- catChan
  12. fmt.Println(cat11, cat22)
  13. fmt.Println(*cat11, *cat22)

}

  2. 5. 案例五
  3. ```go
  4. package main
  6. import "fmt"
  8. type Cat struct {
  9.     Name string
  10.     Age int
  11. }
  14. func main() {
  15.     var allChan chan interface{}
  16.     allChan = make(chan interface{}, 10)
  18.     cat1 := Cat{Name: "Tom", Age: 18,}
  19.     cat2 := Cat{Name: "Tom~", Age: 180,}
  21.     allChan <- cat1
  22.     allChan <- cat2
  23.     allChan <- 10
  24.     allChan <- "jack"
  26.     //取出
  27.     cat11 := <- allChan
  28.     cat22 := <- allChan
  29.     v1 := <- allChan
  30.     v2 := <- allChan
  31.     fmt.Println(cat11, cat22, v1, v2)
  32. }
  1. 案例六 ```go package main

import “fmt”

type Cat struct { Name string Age int }

func main() { var allChan chan interface{} allChan = make(chan interface{}, 10)

  1. cat1 := Cat{Name: "Tom", Age: 18,}
  2. cat2 := Cat{Name: "Tom~", Age: 180,}
  4. allChan <- cat1
  5. allChan <- cat2
  6. allChan <- 10
  7. allChan <- "jack"
  9. //取出
  10. cat11 := <- allChan
  12. fmt.Printf("cat11 = %T cat11 = %v \n", cat11, cat11)
  13. // fmt.Println(cat11.Name) 报错，需要用到类型断言
  14. cat33 := cat11.(Cat)
  15. fmt.Println(cat33.Name)

}

  1. <a name="cfb614ed"></a>
  2. ### channel 的遍历和关闭
  3. <a name="2191bc5a"></a>
  4. #### channel 的关闭
  6. 1. 使用内置函数 close 可以关闭 channel，当 channel 关闭后，就不能再向channel 写入数据了，但是仍然可以从该 channel 读取数据。
  7. 1. 案例演示
  8. ```go
  9. package main
  11. import "fmt"
  13. func main() {
  15.     intChan := make(chan int, 3)
  16.     intChan <- 100
  17.     intChan <- 200
  19.     close(intChan) //close
  21.     //这是不能够再写入数到 channel
  22.     //intChan <- 300
  23.     //fmt.Println("okok~")
  25.     //当管道关闭后，读取数据是可以的
  26.     n1 := <- intChan
  27.     fmt.Println("n1 =", n1)
  28. }

channel 的遍历

  1. channel 支持 for-range 的方式进行遍历，请注意两个细节
    • 在遍历时，如果 channel 没有关闭，则会出现 deadlock 的错误。
    • 在遍历时，如果 channel 已经关闭，则会正常遍历数据，遍历完后，就会退出遍历。
  2. 案例演示 ```go package main

import “fmt”

func main() { //遍历管道 intChan := make(chan int, 100) for i := 0; i < 100; i++ { intChan <- i * 2 //放入100个数据到管道 }

  1. //遍历管道不能使用普通的 for 循环结构
  3. //在遍历时，如果 channel 没有关闭，则会出现 deadlock 的错误。
  4. close(intChan) //关闭管道
  5. for value := range intChan {
  6.     fmt.Println("value = ", value)
  7. }

}

  1. <a name="1c689c03"></a>
  2. #### goroutine 和 channel 结合
  4. 1. 应用案例 
  5.    - 开启一个 writeData 协程，向管道 intChan 中写入 50 个整数。 
  6.    - 开启一个readData 协程，从管道 intChan 中读取 writeData 写入的数据。 
  7.    - 注意：writeData 和 readData 操作的是同一个管道 
  8.    - 主线程需要等待 writeData 和 readData 协程都完成工作才能退出。 
  9. ```go
  10. package main
  12. import (
  13.     "fmt"
  14. )
  17. /*
  18.     案例要求：
  19.         (1) 开启一个 writeData 协程，向管道 intChan 中写入50个整数。
  20.         (2) 开启一个readData 协程，从管道 intChan 中读取 writeData 写入的数据。
  21.         (3) 注意：writeData 和 readData 操作的是同一个管道
  22.         (4) 主线程需要等待 writeData 和 readData 协程都完成工作才能退出。
  23. */
  25. func writeData(intChan chan int) {
  26.     for i := 1; i <= 50; i++ {
  27.         //放入数据
  28.         intChan <- i
  29.         fmt.Println("writeData value =", i)
  30.         //time.Sleep(time.Second)
  31.     }
  32.     close(intChan) // close()
  33. }
  35. func readData(intChan chan int, exitChan chan bool) {
  36.     for {
  37.         value , ok := <- intChan
  38.         if !ok {
  39.             break
  40.         } else {
  41.             //time.Sleep(time.Second)
  42.             fmt.Println("readData() value =", value)
  43.         }
  44.     }
  45.     //readData 读取完数据后，即任务完成
  46.     exitChan <- true
  47.     close(exitChan)
  48. }
  50. func main() {
  51.     //创建两个管道
  52.     intChan := make(chan int, 50)
  53.     exitChan := make(chan bool, 3)
  55.     go writeData(intChan)
  56.     go readData(intChan, exitChan)
  58.     for {
  59.         _, ok := <- exitChan
  60.         if !ok {
  61.             break
  62.         }
  63.     }
  65. }

  1. 应用案例

    1. func main() {
    2.  intChan := make(chan int, 10) //50->10
    3.  exitChan := make(chan bool, 1)
    4.  go writeData(intChan)
    5.  go readData(intChan, exitChan)
    7.  //就是为了等待...readData 协程完成
    8.  for _ := range exitChan {
    9.      fmt.Println("ok...")
    10.  }
    11. }

  2. 对上面问题分析

    • 对上面 go readData(intChan, exitChan) 注销，会造成 dead lock！
    • 如果只向管道写入数据，而没有读取，就会出现阻塞而 dead lock，原因是 intChan 容量是10，而代码 writeData 会写入50个数据，因此会阻塞。
    • 如果编译器(运行)，只有写，而没有毒，则该管道会堵塞；如果写管道和读管道的频率不一致，无所谓。
  3. 应用实例
    • 需求：要求统计1-80000的数字中，哪些是素数？
      • 分析思路：
        • 传统的方法，就是使用一个循环，循环的判断各个数是不是素数。
          • 使用并发/并行的方式，将统计素数的任务分配给多个(4个) goroutine 去完成，完成任务时间短。 ```go package main

import ( “fmt” “time” )

// intChan 放入 1-8000个数 func putNum(intChan chan int) { for i := 0; i < 8000; i++ { intChan <- i }

  1. //关闭 intChan
  2. close(intChan)

}

// 从 intChan 取出数据，并判断是否为素数，如果是，就放入 primeChan func primeNum(intChan chan int, primeChan chan int, exitChan chan bool) {

  1. // 使用 for 循环
  2. var flag bool
  3. for {
  4.     time.Sleep(time.Microsecond)
  5.     num, ok := <- intChan
  6.     if !ok { //intChan 取不到
  7.         break
  8.     }
  9.     flag = true //假设是素数
  10.     //判断 num 是不是素数
  11.     for i := 2; i < num; i++ {
  12.         if num % i == 0{
  13.             //说明该 num 不是素数
  14.             flag = false
  15.             break
  16.         }
  17.     }
  18.     if flag {
  19.         //将这个数放入到 primeChan
  20.         primeChan <- num
  21.     }
  22. }
  24. fmt.Println("有一个 primeNum 协程取不到数据，退出")
  25. //这里我们还不能关闭 primeChan
  26. //向 exitChan 写入 true
  27. exitChan <- true

}

func main() {

  1. intChan := make(chan int, 1000)
  2. primeChan := make(chan int, 2000) //放结果
  4. //表示退出的管道
  5. exitChan := make(chan bool, 4) //4个
  7. //开启一个协程，向 intChan 放入 1-8000个数
  8. go putNum(intChan)
  9. //开启四个协程， 从 intChan 取出数据，并判断是否为素数，如果是，就放入 primeChan
  10. for i := 0; i < 4; i++ {
  11.     go primeNum(intChan, primeChan, exitChan)
  12. }
  14. //这里我们主线程，进行处理
  15. //直接
  16. go func() {
  17.     for i := 0; i < 4; i++ {
  18.         <-exitChan
  19.     }
  21.     //当我们从 exitchan 取出 4 个结果，就可以放心关闭 primeNum
  22.     close(primeChan)
  23. }()
  25. //遍历我们的 primeNum，把结果取出
  26. for {
  27.     result, ok := <- primeChan
  28.     if !ok {
  29.         break
  30.     } else {
  31.         //将结果输出
  32.         fmt.Printf("素数 = %d \n", result)
  33.     }
  34. }
  36. fmt.Println("main() 主线程退出...")

}

  2. 5. 协程求素数代码效率测试
  3. ```go
  4. /main/main.go
  5. package main
  7. import (
  8.     "fmt"
  9.     "time"
  10. )
  13. // intChan 放入 1-8000个数
  14. func putNum(intChan chan int) {
  15.     for i := 0; i < 800000; i++ {
  16.         intChan <- i
  17.     }
  19.     //关闭 intChan
  20.     close(intChan)
  21. }
  24. // 从 intChan 取出数据，并判断是否为素数，如果是，就放入 primeChan
  25. func primeNum(intChan chan int, primeChan chan int, exitChan chan bool) {
  27.     // 使用 for 循环
  28.     var flag bool
  29.     for {
  30.         //time.Sleep(time.Microsecond)
  31.         num, ok := <- intChan
  32.         if !ok { //intChan 取不到
  33.             break
  34.         }
  35.         flag = true //假设是素数
  36.         //判断 num 是不是素数
  37.         for i := 2; i < num; i++ {
  38.             if num % i == 0{
  39.                 //说明该 num 不是素数
  40.                 flag = false
  41.                 break
  42.             }
  43.         }
  44.         if flag {
  45.             //将这个数放入到 primeChan
  46.             primeChan <- num
  47.         }
  48.     }
  50.     fmt.Println("有一个 primeNum 协程取不到数据，退出")
  51.     //这里我们还不能关闭 primeChan
  52.     //向 exitChan 写入 true
  53.     exitChan <- true
  54. }
  57. func main() {
  59.     intChan := make(chan int, 1000)
  60.     primeChan := make(chan int, 200000) //放结果
  62.     //表示退出的管道
  63.     exitChan := make(chan bool, 4) //4个
  65.     start := time.Now().Unix()
  66.     //开启一个协程，向 intChan 放入 1-8000个数
  67.     go putNum(intChan)
  68.     //开启四个协程， 从 intChan 取出数据，并判断是否为素数，如果是，就放入 primeChan
  69.     for i := 0; i < 4; i++ {
  70.         go primeNum(intChan, primeChan, exitChan)
  71.     }
  73.     //这里我们主线程，进行处理
  74.     //直接
  75.     go func() {
  76.         for i := 0; i < 4; i++ {
  77.             <-exitChan
  78.         }
  80.         end := time.Now().Unix()
  81.         fmt.Println("使用协程耗费的时间 =", end - start)
  83.         //当我们从 exitChan 取出 4 个结果，就可以放心关闭 primeNum
  84.         close(primeChan)
  86.     }()
  88.     //遍历我们的 primeNum，把结果取出
  89.     for {
  90.         _, ok := <- primeChan
  91.         if !ok {
  92.             break
  93.         } else {
  94.             //将结果输出
  95.             //fmt.Printf("素数 = %d \n", result)
  96.         }
  97.     }
  99.     fmt.Println("main() 主线程退出...")
  101. }
  1. 传统求素数方法代码效率测试 ```go /test/test.go package main

import ( “fmt” “time” )

func main() { start := time.Now().Unix() for num := 1; num <= 800000; num++ { flag := true //假设是素数 //判断 num 是不是素数 for i := 2; i < num; i++ { if num % i == 0{ //说明该 num 不是素数 flag = false break } } if flag { //将这个数放入到 primeChan //primeChan <- num } } end := time.Now().Unix() fmt.Println(“普通的方法耗时 = “, end - start) }

  2. 7. 结论
  3.    - 使用 go 协程，执行的速度比普通方法提高了至少4倍。(跟 CPU 有关系)
  4. <a name="b85589b6"></a>
  5. #### channel 使用细节和注意事项
  7. 1. channel 可以声明为只读，或者只写性质。
  8. 1. channel 只读和只写的最佳实践案例
  9. ```go
  10. package main
  12. import "fmt"
  14. //ch chan<- int, 这样 ch 就只能写操作
  15. func send(ch chan<- int, exitChan chan struct{}) {
  16.     for i := 0; i < 10; i++ {
  17.         ch <- i
  18.     }
  19.     close(ch)
  21.     var a struct{}
  22.     exitChan <- a
  23. }
  25. //ch <-chan int, 这样 ch 就只能读操作
  26. func recv(ch <-chan int, exitChan chan struct{}) {
  27.     for {
  28.         value, ok := <- ch
  29.         if !ok {
  30.             break
  31.         } else {
  32.             fmt.Println(value)
  33.         }
  34.     }
  35.     var a struct{}
  36.     exitChan <- a
  37. }
  40. func main() {
  41.     //默认情况下，管道是双向的
  42.     var ch chan int
  43.     ch = make(chan int, 10)
  44.     exitChan := make(chan struct{}, 2)
  45.     go send(ch, exitChan)
  46.     go recv(ch, exitChan)
  48.     var total = 0
  49.     for b := range exitChan {
  50.         total++
  51.         if total == 2 {
  52.             break
  53.         } else {
  54.             fmt.Println(b)
  55.         }
  56.     }
  58.     fmt.Println("结束....")
  59. }
  1. 使用 select 可以解决从管道取数据的阻塞问题。 ```go package main

import ( “fmt” “time” )

func main() { //使用 select 可以解决从管道取数据的阻塞问题

  1. //1. 定义一个管道 10 个数据 int
  2. intChan := make(chan int, 10)
  3. for i := 0; i < 10; i++ {
  4.     intChan <- i
  5. }
  6. //2. 定义一个管道 5个数据 string
  7. stringChan := make(chan string, 5)
  8. for i := 0; i < 5; i++ {
  9.     stringChan <- "hello" + fmt.Sprintf("%d", i)
  10. }
  12. // 传统的方法在遍历管道时，如果不关闭会阻塞，导致 dead lock!
  13. //在实际开发中，可能不好确定什么时候关闭该管道。
  14. //可以使用 select 方式可以解决
  15. label :
  16. for {
  17.     select {
  18.         case value := <- intChan ://注意：这里，如果 intchan 一直没有关闭，不会一直 dead lock！，会自动到下个 case 匹配
  19.             fmt.Printf("从 intChan 读取的数据 %d \n", value)
  20.             time.Sleep(time.Second)
  21.         case value := <- stringChan :
  22.             fmt.Printf("从 stringChan 读取的数据 %s \n", value)
  23.             time.Sleep(time.Second)
  24.         default:
  25.             fmt.Printf("都取不到，不玩了 \n")
  26.             time.Sleep(time.Second)
  27.             break label
  28.     }
  29. }

}

  2. 4. goroutine 中使用 recover，解决协程中出现 panic，导致程序崩溃问题。
  3. ```go
  4. package main
  6. import (
  7.     "fmt"
  8.     "time"
  9. )
  12. //函数
  13. func sayHello() {
  14.     for i := 0; i < 10; i++ {
  15.         time.Sleep(time.Second)
  16.         fmt.Println("hello, world!")
  17.     }
  18. }
  20. //函数
  21. func test() {
  22.     //这里我们可以使用错误处理机制 defer + recover
  23.     //定义了一个 map
  24.     defer func() {
  25.         //捕获 test 抛出的 panic
  26.         if err := recover(); err != nil {
  27.             fmt.Println("test() 发生错误", err)
  28.         }
  29.     }()
  30.     var myMap map[int]string
  31.     myMap[0] = "golang" //error
  32. }
  34. func main() {
  35.     go sayHello()
  36.     go test()
  38.     for i := 0; i < 10; i++ {
  39.         fmt.Println("main() ok =", i)
  40.         time.Sleep(time.Second)
  41.     }
  42. }
  1. 说明：如果我们起了一个协程，但是这个协程出现 panic， 如果我们没有捕获这个 panic，就会造成整个程序的崩溃，这时我们可以在 goroutine 中使用 recover 来捕获 panic，进行处理，这样即使这个协程发生的问题，但是主线程仍然不受影响，可以继续运行。

课程来源