goroutine 奉行通过通信来共享内存，而不是共享内存来通信。

goroutine

使用go关键字启动goroutine

  1. var wg sync.WaitGroup
  3. func hello(i int) {
  4.     defer wg.Done() // goroutine结束就登记-1
  5.     fmt.Println("Hello Goroutine!", i)
  6. }
  7. func main() {
  9.     for i := 0; i < 10; i++ {
  10.         wg.Add(1) // 启动一个goroutine就登记+1
  11.         go hello(i)
  12.     }
  13.     wg.Wait() // 等待所有登记的goroutine都结束
  14. }

runtime

runtime.Gosched()

让出CPU时间片，重新等待安排任务

  1. package main
  3. import (
  4.     "fmt"
  5.     "runtime"
  6. )
  8. func main() {
  9.     go func(s string) {
  10.         for i := 0; i < 2; i++ {
  11.             fmt.Println(s)
  12.         }
  13.     }("world")
  14.     // 主协程
  15.     for i := 0; i < 2; i++ {
  16.         // 切一下，再次分配任务
  17.         runtime.Gosched()
  18.         fmt.Println("hello")
  19.     }
  20. }

runtime.Goexit()

退出当前协程

  1. package main
  3. import (
  4.     "fmt"
  5.     "runtime"
  6. )
  8. func main() {
  9.     go func() {
  10.         defer fmt.Println("A.defer")
  11.         func() {
  12.             defer fmt.Println("B.defer")
  13.             // 结束协程
  14.             runtime.Goexit()
  15.             defer fmt.Println("C.defer")
  16.             fmt.Println("B")
  17.         }()
  18.         fmt.Println("A")
  19.     }()
  20.     for {
  21.     }
  22. }

Channel

Go 语言中的通道（channel）是一种特殊的类型。通道像一个传送带或者队列，总是遵循先入先出（First In First Out）的规则，保证收发数据的顺序。每一个通道都是一个具体类型的导管，也就是声明channel的时候需要为其指定元素类型。

channel是一种类型，一种引用类型。var 变量 chan 元素类型

举几个例子：

  1. var ch1 chan int   // 声明一个传递整型的通道
  2. var ch2 chan bool  // 声明一个传递布尔型的通道
  3. var ch3 chan []int // 声明一个传递int切片的通道

通道有发送（send）、接收(receive）和关闭（close）三种操作。
发送和接收都使用<-符号。
现在我们先使用以下语句定义一个通道：

  1. ch := make(chan int)

发送

将一个值发送到通道中。

  1. ch <- 10 // 把10发送到ch中

接收

从一个通道中接收值。

  1. x := <- ch // 从ch中接收值并赋值给变量x
  2. <-ch       // 从ch中接收值，忽略结果

关闭

我们通过调用内置的close函数来关闭通道。

  1. close(ch)

关于关闭通道需要注意的事情是，只有在通知接收方goroutine所有的数据都发送完毕的时候才需要关闭通道。通道是可以被垃圾回收机制回收的，它和关闭文件是不一样的，在结束操作之后关闭文件是必须要做的，但关闭通道不是必须的。
关闭后的通道有以下特点：

  1. 对一个关闭的通道再发送值就会导致panic。
  2. 对一个关闭的通道进行接收会一直获取值直到通道为空。
  3. 对一个关闭的并且没有值的通道执行接收操作会得到对应类型的零值。

  4. 关闭一个已经关闭的通道会导致panic。

    单向通道

    有的时候我们会将通道作为参数在多个任务函数间传递，很多时候我们在不同的任务函数中使用通道都会对其进行限制，比如限制通道在函数中只能发送或只能接收。
    Go语言中提供了单向通道来处理这种情况。例如，我们把上面的例子改造如下：

    1. func counter(out chan<- int) {
    2.  for i := 0; i < 100; i++ {
    3.      out <- i
    4.  }
    5.  close(out)
    6. }
    7. func squarer(out chan<- int, in <-chan int) {
    8.  for i := range in {
    9.      out <- i * i
    10.  }
    11.  close(out)
    12. }
    13. func printer(in <-chan int) {
    14.  for i := range in {
    15.      fmt.Println(i)
    16.  }
    17. }
    18. func main() {
    19.  ch1 := make(chan int)
    20.  ch2 := make(chan int)
    21.  go counter(ch1)
    22.  go squarer(ch2, ch1)
    23.  printer(ch2)
    24. }

    其中，

  5. chan<- int是一个只能发送的通道，可以发送但是不能接收；

  6. <-chan int是一个只能接收的通道，可以接收但是不能发送。

在函数传参及任何赋值操作中将双向通道转换为单向通道是可以的，但反过来是不可以的。

goroutine池

  1. package main
  3. import (
  4.     "fmt"
  5.     "math/rand"
  6. )
  8. type Job struct {
  9.     // id
  10.     Id int
  11.     // 需要计算的随机数
  12.     RandNum int
  13. }
  15. type Result struct {
  16.     // 这里必须传对象实例
  17.     job *Job
  18.     // 求和
  19.     sum int
  20. }
  22. func main() {
  23.     // 需要2个管道
  24.     // 1.job管道
  25.     jobChan := make(chan *Job, 128)
  26.     // 2.结果管道
  27.     resultChan := make(chan *Result, 128)
  28.     // 3.创建工作池
  29.     createPool(64, jobChan, resultChan)
  30.     // 4.开个打印的协程
  31.     go func(resultChan chan *Result) {
  32.         // 遍历结果管道打印
  33.         for result := range resultChan {
  34.             fmt.Printf("job id:%v randnum:%v result:%d\n", result.job.Id,
  35.                 result.job.RandNum, result.sum)
  36.         }
  37.     }(resultChan)
  38.     var id int
  39.     // 循环创建job，输入到管道
  40.     for {
  41.         id++
  42.         // 生成随机数
  43.         r_num := rand.Int()
  44.         job := &Job{
  45.             Id:      id,
  46.             RandNum: r_num,
  47.         }
  48.         jobChan <- job
  49.     }
  50. }
  52. // 创建工作池
  53. // 参数1：开几个协程
  54. func createPool(num int, jobChan chan *Job, resultChan chan *Result) {
  55.     // 根据开协程个数，去跑运行
  56.     for i := 0; i < num; i++ {
  57.         go func(jobChan chan *Job, resultChan chan *Result) {
  58.             // 执行运算
  59.             // 遍历job管道所有数据，进行相加
  60.             for job := range jobChan {
  61.                 // 随机数接过来
  62.                 r_num := job.RandNum
  63.                 // 随机数每一位相加
  64.                 // 定义返回值
  65.                 var sum int
  66.                 for r_num != 0 {
  67.                     tmp := r_num % 10
  68.                     sum += tmp
  69.                     r_num /= 10
  70.                 }
  71.                 // 想要的结果是Result
  72.                 r := &Result{
  73.                     job: job,
  74.                     sum: sum,
  75.                 }
  76.                 //运算结果扔到管道
  77.                 resultChan <- r
  78.             }
  79.         }(jobChan, resultChan)
  80.     }
  81. }

定时器

  • timer 时间到了，执行一次 ```go package main

import ( “fmt” “time” )

func main() { // 1.timer基本使用 //timer1 := time.NewTimer(2 * time.Second) //t1 := time.Now() //fmt.Printf(“t1:%v\n”, t1) //t2 := <-timer1.C //fmt.Printf(“t2:%v\n”, t2)

  1. // 2.验证timer只能响应1次
  2. //timer2 := time.NewTimer(time.Second)
  3. //for {
  4. // <-timer2.C
  5. // fmt.Println("时间到")
  6. //}
  8. // 3.timer实现延时的功能
  9. //(1)
  10. //time.Sleep(time.Second)
  11. //(2)
  12. //timer3 := time.NewTimer(2 * time.Second)
  13. //<-timer3.C
  14. //fmt.Println("2秒到")
  15. //(3)
  16. //<-time.After(2*time.Second)
  17. //fmt.Println("2秒到")
  19. // 4.停止定时器
  20. //timer4 := time.NewTimer(2 * time.Second)
  21. //go func() {
  22. // <-timer4.C
  23. // fmt.Println("定时器执行了")
  24. //}()
  25. //b := timer4.Stop()
  26. //if b {
  27. // fmt.Println("timer4已经关闭")
  28. //}
  30. // 5.重置定时器
  31. timer5 := time.NewTimer(3 * time.Second)
  32. timer5.Reset(1 * time.Second)
  33. fmt.Println(time.Now())
  34. fmt.Println(<-timer5.C)
  36. for {
  37. }

}

  2. - ticker 时间到了，多次执行
  3. ```go
  4. package main
  6. import (
  7.     "fmt"
  8.     "time"
  9. )
  11. func main() {
  12.     // 1.获取ticker对象
  13.     ticker := time.NewTicker(1 * time.Second)
  14.     i := 0
  15.     // 子协程
  16.     go func() {
  17.         for {
  18.             //<-ticker.C
  19.             i++
  20.             fmt.Println(<-ticker.C)
  21.             if i == 5 {
  22.                 //停止
  23.                 ticker.Stop()
  24.             }
  25.         }
  26.     }()
  27.     for {
  28.     }
  29. }

并发安全和锁

有时候在Go代码中可能会存在多个goroutine同时操作一个资源（临界区），这种情况会发生竞态问题（数据竞态）。类比现实生活中的例子有十字路口被各个方向的的汽车竞争；还有火车上的卫生间被车厢里的人竞争。
举个例子：

  1. var x int64
  2. var wg sync.WaitGroup
  3. func add() {
  4.     for i := 0; i < 5000; i++ {
  5.         x = x + 1
  6.     }
  7.     wg.Done()
  8. }
  9. func main() {
  10.     wg.Add(2)
  11.     go add()
  12.     go add()
  13.     wg.Wait()
  14.     fmt.Println(x)
  15. }

上面的代码中我们开启了两个goroutine去累加变量x的值，这两个goroutine在访问和修改x变量的时候就会存在数据竞争，导致最后的结果与期待的不符。

互斥锁

互斥锁是一种常用的控制共享资源访问的方法，它能够保证同时只有一个goroutine可以访问共享资源。Go语言中使用sync包的Mutex类型来实现互斥锁。 使用互斥锁来修复上面代码的问题：

  1. var x int64
  2. var wg sync.WaitGroup
  3. var lock sync.Mutex
  4. func add() {
  5.     for i := 0; i < 5000; i++ {
  6.         lock.Lock() // 加锁
  7.         x = x + 1
  8.         lock.Unlock() // 解锁
  9.     }
  10.     wg.Done()
  11. }
  12. func main() {
  13.     wg.Add(2)
  14.     go add()
  15.     go add()
  16.     wg.Wait()
  17.     fmt.Println(x)
  18. }

使用互斥锁能够保证同一时间有且只有一个goroutine进入临界区，其他的goroutine则在等待锁；当互斥锁释放后，等待的goroutine才可以获取锁进入临界区，多个goroutine同时等待一个锁时，唤醒的策略是随机的。

读写互斥锁

互斥锁是完全互斥的，但是有很多实际的场景下是读多写少的，当我们并发的去读取一个资源不涉及资源修改的时候是没有必要加锁的，这种场景下使用读写锁是更好的一种选择。读写锁在Go语言中使用sync包中的RWMutex类型。
读写锁分为两种：读锁和写锁。当一个goroutine获取读锁之后，其他的goroutine如果是获取读锁会继续获得锁，如果是获取写锁就会等待；当一个goroutine获取写锁之后，其他的goroutine无论是获取读锁还是写锁都会等待。
读写锁示例：

  1. var (
  2.     x      int64
  3.     wg     sync.WaitGroup
  4.     lock   sync.Mutex
  5.     rwlock sync.RWMutex
  6. )
  7. func write() {
  8.     // lock.Lock()   // 加互斥锁
  9.     rwlock.Lock() // 加写锁
  10.     x = x + 1
  11.     time.Sleep(10 * time.Millisecond) // 假设读操作耗时10毫秒
  12.     rwlock.Unlock()                   // 解写锁
  13.     // lock.Unlock()                     // 解互斥锁
  14.     wg.Done()
  15. }
  16. func read() {
  17.     // lock.Lock()                  // 加互斥锁
  18.     rwlock.RLock()               // 加读锁
  19.     time.Sleep(time.Millisecond) // 假设读操作耗时1毫秒
  20.     rwlock.RUnlock()             // 解读锁
  21.     // lock.Unlock()                // 解互斥锁
  22.     wg.Done()
  23. }
  24. func main() {
  25.     start := time.Now()
  26.     for i := 0; i < 10; i++ {
  27.         wg.Add(1)
  28.         go write()
  29.     }
  30.     for i := 0; i < 1000; i++ {
  31.         wg.Add(1)
  32.         go read()
  33.     }
  34.     wg.Wait()
  35.     end := time.Now()
  36.     fmt.Println(end.Sub(start))
  37. }

需要注意的是读写锁非常适合读多写少的场景，如果读和写的操作差别不大，读写锁的优势就发挥不出来。