Go语言学习教程（十五）

一、线程休眠

* Go语言中main()函数为主线程(协程),程序是从上向下执行的

* 可以通过time包下的Sleep(n)让程序阻塞多少纳秒

   //单位是纳秒,表示阻塞多长时间

   //e9表示10的9次方

   time.Sleep(1e9)

二、延迟执行

* 延迟指定时间后执行一次,但是需要注意在触发时程序没有结束

    fmt.Println("开始")

   //2秒后执行匿名函数

   time.AfterFunc(2e9, func() {

      fmt.Println("延迟延迟触发")

   })

   time.Sleep(10e9)//一定要休眠,否则程序结束了

   fmt.Println("结束")

三、goroutine简介

* Golang中最迷人的一个优点就是从语言层面就支持并发

* 在Golang中的goroutine(协程)类似于其他语言的线程

* 并发和并行

    * 并行(parallelism)指不同的代码片段同时在不同的物理处理器上支持

    * 并发(concurrency)指同时管理多个事情,物理处理器上可能运行某个内容一半后就处理其他事情

    * 在一般看来并发的性能要好于并行.因为计算机的物理资源是固定的,较少的,而程序需要执行的内容是很多的.所以并发是”以较少的资源去去做更多事情”

* 几种主流并发模型

    * 多线程,每个线程只处理一个请求,只有请求结束后,对应的线程才会接收下一个请求.这种模式在高并发下,性能开销极大.

    * 基于回调的异步IO.在程序运行过程中可能产生大量回调导致维护成本加大,程序执行流程也不便于思维

    * 协程.不需要抢占式调用,可以有效提升线程任务的并发性,弥补了多线程模式的缺点;Golang在语言层面就支持,而其他语言很少支持

* goroutine的语法

    * 表达式可以是一条语句

    * 表达式也可以是函数,函数返回值即使有,也无效,当函数执行完成此goroutine自动结束

    go 表达式

四、WaitGroup简介

* Golang中sync包提供了基本同步基元,如互斥锁等.除了Once和WaitGroup类型, 大部分都只适用于低水平程序线程,高水平同步线程使用channel通信更好一些

* WaitGroup直译为等待组,其实就是计数器,只要计数器中有内容将一直阻塞

* 在Golang中WaitGroup存在于sync包中,在sync包中类型都是不应该被拷贝的

* Go语言标准库中WaitGroup只有三个方法

    * Add(delta int)表示向内部计数器添加增量(delta),其中参数delta可以是负数

    * Done()表示减少WaitGroup计数器的值,应当在程序最后执行.相当于Add(-1)

    * Wait()表示阻塞直到WaitGroup计数器为0

* 使用WaitGroup可以有效解决goroutine未执行完成而主协程执行完成，导致程序结束的goroutine未执行问题

    var wg sync.WaitGroup

    func main() {

       for i := 1; i <= 3; i++ {

          wg.Add(1)

          go demo(i)

       }

   //阻塞,知道WaitGroup队列中所有任务执行结束时自动解除阻塞

   fmt.Println("开始阻塞")

   wg.Wait()

   fmt.Println("任务执行结束,解除阻塞")

}

func demo(index int) {

   for i := 1; i <= 5; i++ {

      fmt.Printf("第%d次执行,i的值为:%d\n", index, i)

   }

   wg.Done()

}

五、互斥锁

* Go语言中多个协程操作一个变量时会出现冲突的问题

* go run -race 可以查看竞争

* 可以使用sync.Mutex对内容加锁

* 互斥锁的使用场景

    * 多个goroutine访问同一个函数(代码段)

    * 这个函数操作一个全局变量

    * 为了保证共享变量安全性,值合法性

* 使用互斥锁模拟售票窗口

var (

   //票数

   num = 100

   wg  sync.WaitGroup

   //互斥锁

   mu sync.Mutex

)

func sellTicker(i int) {

   defer wg.Done()

   for {

      //加锁,多个goroutine互斥

      mu.Lock()

      if num >= 1 {

         fmt.Println("第", i, "个窗口卖了", num)

         num = num - 1

      }

      //解锁

      mu.Unlock()

      if num <= 0 {

         break

      }

      //添加休眠,防止结果可能出现在一个goroutine中

      time.Sleep(time.Duration(rand.Int63n(1000) * 1e6))

   }

}

func main() {

   //设置随机数种子

   rand.Seed(time.Now().UnixNano())

   //计算器的起始值和票数相同

   wg.Add(4)

   go sellTicker(1)

   go sellTicker(2)

   go sellTicker(3)

   go sellTicker(4)

   wg.Wait()

   fmt.Println("所有票卖完")

}

六、读写锁

* Go语言中的map不是线程安全的,多个goroutine同时操作会出现错误.

* RWMutex可以添加多个读锁或一个写锁.读写锁不能同时存在.

    * map在并发下读写就需要结合读写锁完成

    * 互斥锁表示锁的代码同一时间只能有一个goroutine运行,而读写锁表示在锁范围内数据的读写操作

func main() {

   var rwm sync.RWMutex

   m := make(map[string]string)

   var wg sync.WaitGroup

   wg.Add(10)

   for i := 0; i < 10; i++ {

      go func(j int) {

         //没有锁在map时可能出现问题

         rwm.Lock()

         m["key"+strconv.Itoa(j)] = "value" + strconv.Itoa(j)

         fmt.Println(m)

         rwm.Unlock()

         wg.Done()

      }(i)

   }

   wg.Wait()

   fmt.Println("程序结束")

}

一、channel

* 线程通信在每个编程语言中都是重难点,在Golang中提供了语言级别的goroutine之间通信:channel

* channel不同的翻译资料叫法不一样.常见的几种叫法

    * 管道

    * 信道

    * 通道

* channel是进程内的通信方式,每个channel只能传递一个类型的值.这个类型需要在声明channel时指定

* channel在Golang中主要的两个作用

    * 同步

    * 通信

* Go语言中channel的关键字是chan

* 声明channel的语法

var 名称 chan 类型

var 名称 chan <- 类型 //只写

var 名称 <- chan 类型//只读

名称:=make(chan int) //无缓存channel

名称:=make(chan int,0)//无缓存channel

名称:=make(chan int,100)//有缓存channel

* 操作channel的语法:(假设定义一个channel名称为ch)

ch <- 值 //向ch中添加一个值

<- ch //从ch中取出一个值

a:=<-ch //从ch中取出一个值并赋值给a

a,b:=<-ch//从ch中取出一个值赋值给a,如果ch已经关闭或ch中没有值,b为false

* 简单无缓存通道代码示例

    * 此代码中如果没有从channel中取值c,d=<-ch语句,程序结束时go func并没有执行

    * 下面代码示例演示了同步操作,类似与WaitGroup功能,保证程序结束时goroutine已经执行完成

    * 向goroutine中添加内容的代码会阻塞goroutine执行,所以要把ch<-1放入到goroutine有效代码最后一行

    * 无论是向channel存数据还是取数据都会阻塞

    * close(channel)关闭channel,关闭后只读不可写

func main() {

   ch := make(chan int)

   go func() {

      fmt.Println("进入goroutine")

      // 添加一个内容后控制台输出:1 true

      //ch<-1

      //关闭ch控制台输出:0 false

      close(ch)

   }()

   c, d := <-ch

   fmt.Println(c, d)

   fmt.Println("程序执行结束")

}

* 使用channel实现goroutine之间通信

    * channel其实就是消息通信机制实现方案,在Golang中没有使用共享内存完成线程通信,而是使用channel实现goroutine之间通信

func main() {

   //用于goroutine之间传递数据

   ch := make(chan string)

   //用于控制程序执行

   ch2 := make(chan string)

   go func() {

      fmt.Println("执行第一个goroutine,等待第二个goroutine传递数据")

      content := <-ch

      fmt.Println("接收到的数据为:", content)

      ch2 <- "第一个"

   }()

   go func() {

      fmt.Println("进入到第二个,开始传递数据")

      ch <- "内容随意"

      close(ch)

      fmt.Println("发送数据完成")

      ch2 <- "第二个"

   }()

   result1 := <-ch2

   fmt.Println(result1, "执行完成")

   result2 := <-ch2

   fmt.Println(result2, "执行完成")

   fmt.Println("程序执行结束")

}

* 可以使用for range获取channel中内容

    * 不需要确定channel中数据个数

func main() {

   ch:=make(chan string)

   ch2:=make(chan int)

   go func() {

      for i:=97;i<97+26;i++{

         ch <- strconv.Itoa(i)

      }

      ch2<-1

   }()

   go func() {

      for c := range ch{

         fmt.Println("取出来的",c)

      }

   }()

   <-ch2

   fmt.Println("程序结束")

}

* channel是安全的.多个goroutine同时操作时,同一时间只能有一个goroutine存取数据

func main() {

   ch := make(chan int)

   for i := 1; i < 5; i++ {

      go func(j int) {

         fmt.Println(j, "开始")

         ch <- j

         fmt.Println(j, "结束")

      }(i)

   }

   for j := 1; j < 5; j++ {

      time.Sleep(2 * time.Second)

      <-ch

   }

}