Go语言入门 — 工程实践之并发 ｜ 青训营笔记

clstilmldy
109 阅读6分钟

Go语言入门 — 工程实践之并发 ｜ 青训营笔记

这是我参与「第三届青训营 -后端场」笔记创作活动的的第3篇笔记

记录我不熟悉与新学习的知识。

并发编程

Goroutine

  • 协程：用户态，轻量级线程-MB级别，协程使用'go'实现
  • 线程：用户态，线程可以并发跑多个协程（上万左右也可）；比协程更耗资源

并发与并行

  • 并发：多线程程序在单核的cpu上运行

  • 并行：多线程程序在多个核的cpu上运行

Go可以充分发挥多核优势，高效运行

推荐阅读

goroutine

使用go关键字开启一个goroutine

  • 线程：用户态，轻量级线程，栈MB级别
  • 协程：内核态，线程跑多个协程，栈KB级别

推荐阅读

单纯地将函数并发执行是没有意义的。函数与函数间需要交换数据才能体现并发执行函数的意义。

虽然可以使用共享内存进行数据交换，但是共享内存在不同的 goroutine 中容易发生竞态问题。为了保证数据交换的正确性，很多并发模型中必须使用互斥量对内存进行加锁，这种做法势必造成性能问题。

Go语言采用的并发模型是CSP（Communicating Sequential Processes），提倡通过通信共享内存而不是通过共享内存而实现通信。

如果说 goroutine 是Go程序并发的执行体，channel就是它们之间的连接。channel是可以让一个 goroutine 发送特定值到另一个 goroutine 的通信机制。

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

CSP (Communicating Sequential Processes)

image.png

go提倡通过通信共享内存而不是通过共享内存而实现通信

go语言中，使用channel通信实现内存共享，也可以通过共享内存实现通信，即使用锁

channel

image.png

make(chan Type, len)

无缓冲通道又称为同步通道：不提供len时

一个生产消费者模型的例子

package main

func CalSquare() {
   src := make(chan int) // 同步通道
   dest := make(chan int, 3) // 有缓冲通道
   go func() {
      defer close(src)
      for i := 0; i < 10; i++ { // 生产
         src <- i
      }
   }()
   go func() {
      defer close(dest)
      for i := range src { // 消费
         dest <- i * i
      }
   }()
   for i := range dest {
      println(i)
   }
}

这个例子最后的结果是有序的（由于生产者为同步通道，消费者为有缓冲通道，消费者需要等待生产者）

并发安全Lock

有时候我们的代码中可能会存在多个 goroutine 同时操作一个资源（临界区）的情况，这种情况下就会发生竞态问题（数据竞态）。

互斥锁

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

sync.Mutex提供了两个方法供我们使用。

方法名功能
func (m *Mutex) Lock()获取互斥锁
func (m *Mutex) Unlock()释放互斥锁

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

读写互斥锁

互斥锁是完全互斥的，但是实际上有很多场景是读多写少的，当我们并发的去读取一个资源而不涉及资源修改的时候是没有必要加互斥锁的，这种场景下使用读写锁是更好的一种选择。读写锁在 Go 语言中使用sync包中的RWMutex类型。

sync.RWMutex提供了以下5个方法。

方法名功能
func (rw *RWMutex) Lock()获取写锁
func (rw *RWMutex) Unlock()释放写锁
func (rw *RWMutex) RLock()获取读锁
func (rw *RWMutex) RUnlock()释放读锁
func (rw *RWMutex) RLocker() Locker返回一个实现Locker接口的读写锁

读写锁分为两种：读锁和写锁。当一个 goroutine 获取到读锁之后，其他的 goroutine 如果是获取读锁会继续获得锁，如果是获取写锁就会等待；而当一个 goroutine 获取写锁之后，其他的 goroutine 无论是获取读锁还是写锁都会等待。

sync.WaitGroup

在代码中生硬的使用time.Sleep肯定是不合适的，Go语言中可以使用sync.WaitGroup来实现并发任务的同步。 sync.WaitGroup有以下几个方法：

方法名功能
func (wg * WaitGroup) Add(delta int)计数器+delta
(wg *WaitGroup) Done()计数器-1
(wg *WaitGroup) Wait()阻塞直到计数器变为0

sync.WaitGroup内部维护着一个计数器，计数器的值可以增加和减少。例如当我们启动了 N 个并发任务时，就将计数器值增加N。每个任务完成时通过调用 Done 方法将计数器减1。通过调用 Wait 来等待并发任务执行完，当计数器值为 0 时，表示所有并发任务已经完成。

sync.Once

在某些场景下我们需要确保某些操作即使在高并发的场景下也只会被执行一次，例如只加载一次配置文件等。

Go语言中的sync包中提供了一个针对只执行一次场景的解决方案——sync.Once，sync.Once只有一个Do方法，其签名如下：

func (o *Once) Do(f func())

注意： 如果要执行的函数f需要传递参数就需要搭配闭包来使用。

sync.Once其实内部包含一个互斥锁和一个布尔值，互斥锁保证布尔值和数据的安全，而布尔值用来记录初始化是否完成。这样设计就能保证初始化操作的时候是并发安全的并且初始化操作也不会被执行多次。

sync.Map

Go 语言中内置的 map 不是并发安全的，Go语言的sync包中提供了一个开箱即用的并发安全版 map——sync.Map。开箱即用表示其不用像内置的 map 一样使用 make 函数初始化就能直接使用。同时sync.Map内置了诸如Store、Load、LoadOrStore、Delete、Range等操作方法。

方法名功能
func (m *Map) Store(key, value interface{})存储key-value数据
func (m *Map) Load(key interface{}) (value interface{}, ok bool)查询key对应的value
func (m *Map) LoadOrStore(key, value interface{}) (actual interface{}, loaded bool)查询或存储key对应的value
func (m *Map) LoadAndDelete(key interface{}) (value interface{}, loaded bool)查询并删除key
func (m *Map) Delete(key interface{})删除key
func (m *Map) Range(f func(key, value interface{}) bool)对map中的每个key-value依次调用f

小结

Goroutine：协程，go可以通过高效地调度模型实现高并发操作

Channel：go提倡通过通信去共享内存

Sync：其中的Lock和WaitGroup关键字，实现并发安全操作和协程间的同步

avatar
文章
阅读
粉丝