Go语言下的并发编程:Goroutine,Channel 和 Sync

开发 后端
在当今这个多核时代,并发编程的意义不言而喻。使用 Go 开发并发程序,操作起来非常简单,语言级别提供关键字 go 用于启动协程,并且在同一台机器上可以启动成千上万个协程。

[[426818]]

优雅的并发编程范式,完善的并发支持,出色的并发性能是 Go 语言区别于其他语言的一大特色。

在当今这个多核时代,并发编程的意义不言而喻。使用 Go 开发并发程序,操作起来非常简单,语言级别提供关键字 go 用于启动协程,并且在同一台机器上可以启动成千上万个协程。

下面就来详细介绍。

goroutine

Go 语言的并发执行体称为 goroutine,使用关键词 go 来启动一个 goroutine。

go 关键词后面必须跟一个函数,可以是有名函数,也可以是无名函数,函数的返回值会被忽略。

go 的执行是非阻塞的。

先来看一个例子:

  1. package main 
  2.  
  3. import ( 
  4.     "fmt" 
  5.     "time" 
  6.  
  7. func main() { 
  8.     go spinner(100 * time.Millisecond) 
  9.     const n = 45 
  10.     fibN := fib(n) 
  11.     fmt.Printf("\rFibonacci(%d) = %d\n", n, fibN) // Fibonacci(45) = 1134903170 
  12.  
  13. func spinner(delay time.Duration) { 
  14.     for { 
  15.         for _, r := range `-\|/` { 
  16.             fmt.Printf("\r%c", r) 
  17.             time.Sleep(delay) 
  18.         } 
  19.     } 
  20.  
  21. func fib(x intint { 
  22.     if x < 2 { 
  23.         return x 
  24.     } 
  25.     return fib(x-1) + fib(x-2) 

从执行结果来看,成功计算出了斐波那契数列的值,说明程序在 spinner 处并没有阻塞,而且 spinner 函数还一直在屏幕上打印提示字符,说明程序正在执行。

当计算完斐波那契数列的值,main 函数打印结果并退出,spinner 也跟着退出。

再来看一个例子,循环执行 10 次,打印两个数的和:

  1. package main 
  2.  
  3. import "fmt" 
  4.  
  5. func Add(x, y int) { 
  6.     z := x + y 
  7.     fmt.Println(z) 
  8.  
  9. func main() { 
  10.     for i := 0; i < 10; i++ { 
  11.         go Add(i, i) 
  12.     } 

有问题了,屏幕上什么都没有,为什么呢?

这就要看 Go 程序的执行机制了。当一个程序启动时,只有一个 goroutine 来调用 main 函数,称为主 goroutine。新的 goroutine 通过 go 关键词创建,然后并发执行。当 main 函数返回时,不会等待其他 goroutine 执行完,而是直接暴力结束所有 goroutine。

那有没有办法解决呢?当然是有的,请往下看。

channel

一般写多进程程序时,都会遇到一个问题:进程间通信。常见的通信方式有信号,共享内存等。goroutine 之间的通信机制是通道 channel。

使用 make 创建通道:

  1. ch := make(chan int) // ch 的类型是 chan int 

通道支持三个主要操作:send,receive 和 close。

  1. ch <- x // 发送 
  2. x = <-ch // 接收 
  3. <-ch // 接收,丢弃结果 
  4.  
  5. close(ch) // 关闭 

无缓冲 channel

make 函数接受两个参数,第二个参数是可选参数,表示通道容量。不传或者传 0 表示创建了一个无缓冲通道。

无缓冲通道上的发送操作将会阻塞,直到另一个 goroutine 在对应的通道上执行接收操作。相反,如果接收先执行,那么接收 goroutine 将会阻塞,直到另一个 goroutine 在对应通道上执行发送。

所以,无缓冲通道是一种同步通道。

下面我们使用无缓冲通道把上面例子中出现的问题解决一下。

  1. package main 
  2.  
  3. import "fmt" 
  4.  
  5. func Add(x, y int, ch chan int) { 
  6.     z := x + y 
  7.     ch <- z 
  8.  
  9. func main() { 
  10.  
  11.     ch := make(chan int
  12.     for i := 0; i < 10; i++ { 
  13.         go Add(i, i, ch) 
  14.     } 
  15.  
  16.     for i := 0; i < 10; i++ { 
  17.         fmt.Println(<-ch) 
  18.     } 

可以正常输出结果。

主 goroutine 会阻塞,直到读取到通道中的值,程序继续执行,最后退出。

缓冲 channel

创建一个容量是 5 的缓冲通道:

  1. ch := make(chan int, 5) 

缓冲通道的发送操作在通道尾部插入一个元素,接收操作从通道的头部移除一个元素。如果通道满了,发送会阻塞,直到另一个 goroutine 执行接收。相反,如果通道是空的,接收会阻塞,直到另一个 goroutine 执行发送。

有没有感觉,其实缓冲通道和队列一样,把操作都解耦了。

单向 channel

类型 chan<- int 是一个只能发送的通道,类型 <-chan int 是一个只能接收的通道。

任何双向通道都可以用作单向通道,但反过来不行。

还有一点需要注意,close 只能用在发送通道上,如果用在接收通道会报错。

看一个单向通道的例子:

  1. package main 
  2.  
  3. import "fmt" 
  4.  
  5. func counter(out chan<- int) { 
  6.     for x := 0; x < 10; x++ { 
  7.         out <- x 
  8.     } 
  9.     close(out
  10.  
  11. func squarer(out chan<- intin <-chan int) { 
  12.     for v := range in { 
  13.         out <- v * v 
  14.     } 
  15.     close(out
  16.  
  17. func printer(in <-chan int) { 
  18.     for v := range in { 
  19.         fmt.Println(v) 
  20.     } 
  21.  
  22. func main() { 
  23.     n := make(chan int
  24.     s := make(chan int
  25.  
  26.     go counter(n) 
  27.     go squarer(s, n) 
  28.     printer(s) 
  29.  

sync

sync 包提供了两种锁类型:sync.Mutex 和 sync.RWMutex,前者是互斥锁,后者是读写锁。

当一个 goroutine 获取了 Mutex 后,其他 goroutine 不管读写,只能等待,直到锁被释放。

  1. package main 
  2.  
  3. import ( 
  4.     "fmt" 
  5.     "sync" 
  6.     "time" 
  7.  
  8. func main() { 
  9.     var mutex sync.Mutex 
  10.     wg := sync.WaitGroup{} 
  11.  
  12.     // 主 goroutine 先获取锁 
  13.     fmt.Println("Locking  (G0)"
  14.     mutex.Lock() 
  15.     fmt.Println("locked (G0)"
  16.  
  17.     wg.Add(3) 
  18.     for i := 1; i < 4; i++ { 
  19.         go func(i int) { 
  20.             // 由于主 goroutine 先获取锁,程序开始 5 秒会阻塞在这里 
  21.             fmt.Printf("Locking (G%d)\n", i) 
  22.             mutex.Lock() 
  23.             fmt.Printf("locked (G%d)\n", i) 
  24.  
  25.             time.Sleep(time.Second * 2) 
  26.             mutex.Unlock() 
  27.             fmt.Printf("unlocked (G%d)\n", i) 
  28.  
  29.             wg.Done() 
  30.         }(i) 
  31.     } 
  32.  
  33.     // 主 goroutine 5 秒后释放锁 
  34.     time.Sleep(time.Second * 5) 
  35.     fmt.Println("ready unlock (G0)"
  36.     mutex.Unlock() 
  37.     fmt.Println("unlocked (G0)"
  38.  
  39.     wg.Wait() 

RWMutex 属于经典的单写多读模型,当读锁被占用时,会阻止写,但不阻止读。而写锁会阻止写和读。

  1. package main 
  2.  
  3. import ( 
  4.     "fmt" 
  5.     "sync" 
  6.     "time" 
  7.  
  8. func main() { 
  9.     var rwMutex sync.RWMutex 
  10.     wg := sync.WaitGroup{} 
  11.  
  12.     Data := 0 
  13.     wg.Add(20) 
  14.     for i := 0; i < 10; i++ { 
  15.         go func(t int) { 
  16.             // 第一次运行后,写解锁。 
  17.             // 循环到第二次时,读锁定后,goroutine 没有阻塞,同时读成功。 
  18.             fmt.Println("Locking"
  19.             rwMutex.RLock() 
  20.             defer rwMutex.RUnlock() 
  21.             fmt.Printf("Read data: %v\n", Data) 
  22.             wg.Done() 
  23.             time.Sleep(2 * time.Second
  24.         }(i) 
  25.         go func(t int) { 
  26.             // 写锁定下是需要解锁后才能写的 
  27.             rwMutex.Lock() 
  28.             defer rwMutex.Unlock() 
  29.             Data += t 
  30.             fmt.Printf("Write Data: %v %d \n", Data, t) 
  31.             wg.Done() 
  32.             time.Sleep(2 * time.Second
  33.         }(i) 
  34.     } 
  35.  
  36.     wg.Wait() 

总结

并发编程算是 Go 的特色,也是核心功能之一了,涉及的知识点其实是非常多的,本文也只是起到一个抛砖引玉的作用而已。

本文开始介绍了 goroutine 的简单用法,然后引出了通道的概念。

通道有三种:

  1. 无缓冲通道
  2. 缓冲通道
  3. 单向通道

最后介绍了 Go 中的锁机制,分别是 sync 包提供的 sync.Mutex(互斥锁) 和 sync.RWMutex(读写锁)。

goroutine 博大精深,后面的坑还是要慢慢踩的。

 

责任编辑:姜华 来源: AlwaysBeta
相关推荐

2024-09-06 10:48:13

2024-10-14 08:51:52

协程Go语言

2024-06-19 10:08:34

GoChannel工具

2022-03-04 10:07:45

Go语言字节池

2021-07-06 07:46:07

Go语言编程

2023-02-10 09:40:36

Go语言并发

2021-06-29 23:40:19

Golang语言并发

2023-12-29 08:42:46

高并发Go语言

2022-08-08 08:31:55

Go 语言闭包匿名函数

2022-08-08 06:50:06

Go语言闭包

2023-11-28 08:01:48

互斥锁共享资源

2023-12-25 09:58:25

sync包Go编程

2024-07-01 08:44:42

Go语言协程

2020-12-27 10:15:44

Go语言channel管道

2022-10-17 08:07:13

Go 语言并发编程

2023-05-24 09:31:51

CGo

2024-09-02 09:00:59

2023-10-20 13:35:19

GoWaitGroup

2023-09-25 12:45:45

Go 语言可视化sync.Mute

2013-05-28 09:43:38

GoGo语言并发模式
点赞
收藏

51CTO技术栈公众号