互斥锁 Mutex

sync.Mutex.lock()
sync.Mutex.unlock()

  1. package main
  3. import (
  4.     "fmt"
  5.     "sync"
  6.     "time"
  7. )
  9. //需求：现在要计算 1-200 的各个数的阶乘，并且把各个数的阶乘放入到map中
  10. //最后显示出来。要求使用goroutine完成
  12. //思路
  13. //1.编写一个函数，来计算各个数的阶乘，并放入到一个map中
  14. //2.我们启动协程多个，统计的结果放入到map中
  15. //3.map应该做成一个全局的
  17. var (
  18.     myMap = make(map[int]int, 10)
  19.     //声明一个全局的互斥锁
  20.     //lock是一个全局的互斥锁
  21.     //sync是包：synchronized
  22.     //Mutex互斥
  23.     lock sync.Mutex
  24. )
  26. func test(n int) {
  27.     res := 1
  28.     for i := 1; i <= n; i++ {
  29.         res *= i
  30.     }
  32.     //这里我们将res放入到map中
  33.     //加锁
  34.     lock.Lock()
  35.     myMap[n] = res
  36.     //解锁
  37.     lock.Unlock()
  38. }
  40. func main() {
  42.     //我们这里开启多个协程完成这个任务
  43.     for i := 0; i < 20; i++ {
  44.         go test(i)
  45.     }
  47.     time.Sleep(time.Second * 10)
  49.     //遍历这个结果
  50.     lock.Lock()
  51.     for i, v := range myMap {
  52.         fmt.Printf("map[%d] = %d\n", i, v)
  53.     }
  54.     lock.Unlock()
  56. }

channel(管道)-基本介绍

为什么需要channel
前面使用全局变量加锁同步来解决goroutine的通讯，但不完美
1）主线程在等待所有goroutine全部完成的时间很难确定，我们这里设置10秒，仅仅是估算。
2）如果主线程休眠时间长了，会加长等待时间，如果等待时间短了，可能还有goroutine处于工作状态，这时也会随主线程的退出而销毁
3）通过全局变量加锁同步实现通讯，也并不利用多个协程对全局变量的读写操作
4）赏面种种分析都在呼唤一个新的通讯机制-channel

channel的介绍
1）channel本质就是一个数据结构-队列
2）线程安全，多goroutine访问时，不需要加锁，就是说channel本身就是线程安全的
3）数据是先进先出【FIFO：first in first out】
4）channel是有类型的，一个string的channel只能存放string类型的数据

channel基本使用
var 变量名 chan 数据类型
举例

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

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

  1. package main
  3. import "fmt"
  5. func main() {
  6.     //演示一下管道的使用
  7.     //1.创建一个可以存放3个int类型的管道
  8.     var intChan chan int
  9.     intChan = make(chan int, 3)
  11.     //2.看看intChan是什么
  12.     fmt.Printf("intChan的值=%v intChan本身的地址=%p\n", intChan, &intChan)
  14.     //3.向管道写入数据
  15.     intChan <- 10
  16.     num := 211
  17.     intChan <- num
  18.     intChan <- 50
  19.     //intChan <- 98//注意点，当我们给管道写入数据时，不能超过其容量
  21.     //4.看看管道的长度和cap（容量）
  22.     fmt.Printf("channel len=%v  vap=%v \n", len(intChan), cap(intChan))
  24.     //5.从管道中读取数据
  25.     var num2 int
  26.     num2 = <-intChan
  27.     fmt.Println("num2=", num2)
  28.     fmt.Printf("channel len=%v  vap=%v \n", len(intChan), cap(intChan))
  30.     //6.在没有使用协程的情况下，如果我们的管道数据已经全部取出，再去就会报错 deadlock
  31. }

channel的遍历和关闭

channnel的关闭
close(管道)
channel的遍历
channel支持for-range的方式进行遍历，请注意两个细节
在遍历时，如果channel没有关闭，则会出现deadlock的错误
在遍历时，如果channel已经关闭，则会正常遍历数据，遍历完后，就会退出遍历

应用

  1. package main
  3. import "fmt"
  5. func writeDate(intChan chan int) {
  6.     for i := 0; i < 50; i++ {
  7.         intChan <- i
  8.     }
  9.     close(intChan)
  10. }
  12. func readDate(intChan chan int, exitChan chan bool) {
  13.     for {
  14.         v, ok := <-intChan
  15.         if !ok {
  16.             break
  17.         }
  18.         fmt.Println("读取到数据", v)
  19.     }
  20.     exitChan <- true
  21.     close(exitChan)
  22. }
  23. func main() {
  25.     //创建两个管道
  26.     intChan := make(chan int, 50)
  27.     exitChan := make(chan bool, 1)
  29.     go writeDate(intChan)
  30.     go readDate(intChan, exitChan)
  32.     for {
  33.         _, ok := <-exitChan
  34.         if !ok {
  35.             break
  36.         }
  37.     }
  38. }

练习
要求：
1）启动一个协程，将1-200的数放入到一个channel中，比如numChan
2）启动8个协程，从numChan取出数（比如n），并计算1+…+n的值，并存放到resChan
3）最后8个协程协同完成工作后，再遍历resChan，显示结果【如res[1]=1…res[10]=55…】
4）注意：考虑resChan chan int是否合适

  1. package main
  3. import (
  4.     "fmt"
  5.     "sync"
  6. )
  8. //定义一个wg,数据类型为WaitGrop,在关闭协程时,需要被用到
  9. var wg sync.WaitGroup
  11. //编写writeData函数
  12. func wtireData(intChan chan<- int) {
  13.     for i := 1; i <= 200; i++ {
  14.         intChan <- i
  15.     }
  16.     close(intChan)
  17.     wg.Done()
  18. }
  20. //编写sumData函数
  21. func sumData(intChan <-chan int, resChan chan<- map[int]int) {
  22.     for {
  23.         v, ok := <-intChan
  24.         if !ok {
  25.             break
  26.         }
  27.         //计算1+2+...n的值
  28.         sum := 0
  29.         for i := 1; i <= v; i++ {
  30.             sum += i
  31.         }
  32.         //将值发送至resChan
  33.         numSum := make(map[int]int)
  34.         numSum[v] = sum
  35.         resChan <- numSum
  36.     }
  37.     //close(resChan)
  38.     wg.Done()
  39. }
  41. //编写readData函数遍历输出
  42. func readData(resChan <-chan map[int]int) {
  43.     for {
  44.         v, ok := <-resChan
  45.         if !ok {
  46.             break
  47.         }
  48.         for index, value := range v {
  49.             fmt.Printf("res[%v]=%v\n", index, value)
  50.         }
  51.     }
  52.     wg.Done()
  53. }
  55. //主函数
  56. func main() {
  57.     intChan := make(chan int, 10)
  58.     resChan := make(chan map[int]int, 10) //根据题目要求我们这里使用map存储计算的值
  60.     //指定当前程序使用协程的个数,你启用多少就填多少,不能多也不能少
  61.     wg.Add(9)
  62.     go wtireData(intChan)
  63.     //启用8个协程处理问题
  64.     for i := 1; i <= 8; i++ {
  65.         go sumData(intChan, resChan)
  66.         go readData(resChan)
  67.     }
  68.     wg.Wait()
  69. }

阻塞案例

  1. package main
  3. import (
  4.     "fmt"
  5.     "sync"
  6. )
  8. var wg sync.WaitGroup
  10. func readData(intChan chan int) {
  11.     for i := 0; i < 50; i++ {
  12.         intChan <- i
  13.         //time.Sleep(time.Second)
  14.     }
  15.     close(intChan)
  16.     wg.Done()
  17. }
  19. func writeData(intChan chan int) {
  20.     for i := range intChan {
  21.         fmt.Println(i)
  22.     }
  23.     wg.Done()
  24. }
  26. func main() {
  28.     intChan := make(chan int, 10)
  29.     wg.Add(2)
  30.     go readData(intChan)
  31.     go writeData(intChan)
  32.     wg.Wait()
  33. }

协程求素数

image.png

  1. package main
  3. import (
  4.     "fmt"
  5.     "sync"
  6. )
  8. var wg = sync.WaitGroup{}
  10. func writeData(intChan chan int) {
  11.     for i := 1; i < 20000; i++ {
  12.         intChan <- i
  13.     }
  14.     close(intChan)
  15.     wg.Done()
  16. }
  18. func prime(intChan chan int, resultChan chan int) {
  19.     for num := range intChan {
  20.         flag := false
  21.         for i := 2; i <= num/2; i++ {
  22.             if num%i == 0 {
  23.                 flag = true
  24.                 break
  25.             }
  26.         }
  27.         if !flag {
  28.             resultChan <- num
  29.             fmt.Println(num)
  30.         }
  31.     }
  32.     wg.Done()
  33. }
  35. func main() {
  36.     wg.Add(5)
  37.     intChan := make(chan int, 1000)
  38.     resultChan := make(chan int, 10000)
  39.     go writeData(intChan)
  40.     for i := 0; i < 4; i++ {
  41.         go prime(intChan, resultChan)
  42.     }
  44.     wg.Wait()
  45. }

channel使用细节

  • 管道可以声明为只读或者只写 ```go //默认情况下，管道是双向的 var chan1 chan int

//声明为只写 var chan2 chan <- int

//声明为只读 car chan3 <-chan int

  2. - 使用select可以解决管道阻塞问题
  3. ```go
  4. package main
  6. import (
  7.     "fmt"
  8.     "time"
  9. )
  11. func main() {
  12.     //使用select可以解决从管道取数据阻塞问题
  14.     //1.定义一个管道 10个数据int
  15.     intChan := make(chan int, 10)
  16.     for i := 0; i < 10; i++ {
  17.         intChan <- i
  18.     }
  19.     //2.定义一个管道 5个数据string
  20.     stringChan := make(chan string, 5)
  21.     for i := 0; i < 5; i++ {
  22.         stringChan <- "hello" + fmt.Sprintf("%d", i)
  23.     }
  25.     //传统的方法在遍历管道时，如果不关闭会阻塞导致deadlock
  27.     //问题：在实际开发中，我们不好确定什么时候关闭该管道
  28.     //可以使用select方式解决
  29. label:
  30.     for {
  31.         select {
  32.         //注意：这里，如果intChan一直没有关闭，不会一直阻塞而deadlock
  33.         //会自动到下一个case匹配
  34.         case v := <-intChan:
  35.             fmt.Printf("从intChan读取的数据%d\n", v)
  36.             time.Sleep(time.Second)
  37.         case v := <-stringChan:
  38.             fmt.Printf("从stringChan读取到数据%s\n", v)
  39.             time.Sleep(time.Second)
  40.         default:
  41.             fmt.Println("都取不到了")
  42.             break label
  43.         }
  44.     }
  45. }
  • goroutine中使用recover，解决协程中出现panic，导致程序崩溃问题 ```go package main

import ( “fmt” “sync” “time” )

var wg sync.WaitGroup

func sayHello() { for i := 0; i < 10; i++ { time.Sleep(time.Second) fmt.Println(“hello world”) } wg.Done() }

func test() { //我们这里可以使用defer+recover defer func() { //捕获test抛出panic if err := recover(); err != nil { fmt.Println(“test()发生错误”, err) wg.Done() } }()

  1. var myMap map[int]string
  2. myMap[0] = "golang"
  3. wg.Done()

}

func main() { wg.Add(2) go sayHello() go test() wg.Wait()

}

```