Go 专栏|并发编程:goroutine,channel 和 sync

简介: Go 专栏|并发编程:goroutine,channel 和 sync

QQ图片20220423133827.png

原文链接:Go 专栏|并发编程:goroutine,channel 和 sync


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


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


下面就来详细介绍。


goroutine


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


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


go 的执行是非阻塞的。


先来看一个例子:


package main
import (
  "fmt"
  "time"
)
func main() {
  go spinner(100 * time.Millisecond)
  const n = 45
  fibN := fib(n)
  fmt.Printf("\rFibonacci(%d) = %d\n", n, fibN) // Fibonacci(45) = 1134903170
}
func spinner(delay time.Duration) {
  for {
    for _, r := range `-\|/` {
      fmt.Printf("\r%c", r)
      time.Sleep(delay)
    }
  }
}
func fib(x int) int {
  if x < 2 {
    return x
  }
  return fib(x-1) + fib(x-2)
}
复制代码


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


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


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


package main
import "fmt"
func Add(x, y int) {
  z := x + y
  fmt.Println(z)
}
func main() {
  for i := 0; i < 10; i++ {
    go Add(i, i)
  }
}
复制代码


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


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


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


channel


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


使用 make 创建通道:


ch := make(chan int) // ch 的类型是 chan int
复制代码


通道支持三个主要操作:sendreceiveclose


ch <- x // 发送
x = <-ch // 接收
<-ch // 接收,丢弃结果
close(ch) // 关闭
复制代码


无缓冲 channel


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


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


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


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


package main
import "fmt"
func Add(x, y int, ch chan int) {
  z := x + y
  ch <- z
}
func main() {
  ch := make(chan int)
  for i := 0; i < 10; i++ {
    go Add(i, i, ch)
  }
  for i := 0; i < 10; i++ {
    fmt.Println(<-ch)
  }
}
复制代码


可以正常输出结果。


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


缓冲 channel


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


ch := make(chan int, 5)
复制代码


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


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


单向 channel


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


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


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


看一个单向通道的例子:


package main
import "fmt"
func counter(out chan<- int) {
  for x := 0; x < 10; x++ {
    out <- x
  }
  close(out)
}
func squarer(out chan<- int, in <-chan int) {
  for v := range in {
    out <- v * v
  }
  close(out)
}
func printer(in <-chan int) {
  for v := range in {
    fmt.Println(v)
  }
}
func main() {
  n := make(chan int)
  s := make(chan int)
  go counter(n)
  go squarer(s, n)
  printer(s)
}
复制代码


sync


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


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


package main
import (
  "fmt"
  "sync"
  "time"
)
func main() {
  var mutex sync.Mutex
  wg := sync.WaitGroup{}
  // 主 goroutine 先获取锁
  fmt.Println("Locking  (G0)")
  mutex.Lock()
  fmt.Println("locked (G0)")
  wg.Add(3)
  for i := 1; i < 4; i++ {
    go func(i int) {
      // 由于主 goroutine 先获取锁,程序开始 5 秒会阻塞在这里
      fmt.Printf("Locking (G%d)\n", i)
      mutex.Lock()
      fmt.Printf("locked (G%d)\n", i)
      time.Sleep(time.Second * 2)
      mutex.Unlock()
      fmt.Printf("unlocked (G%d)\n", i)
      wg.Done()
    }(i)
  }
  // 主 goroutine 5 秒后释放锁
  time.Sleep(time.Second * 5)
  fmt.Println("ready unlock (G0)")
  mutex.Unlock()
  fmt.Println("unlocked (G0)")
  wg.Wait()
}
复制代码


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


package main
import (
  "fmt"
  "sync"
  "time"
)
func main() {
  var rwMutex sync.RWMutex
  wg := sync.WaitGroup{}
  Data := 0
  wg.Add(20)
  for i := 0; i < 10; i++ {
    go func(t int) {
      // 第一次运行后,写解锁。
      // 循环到第二次时,读锁定后,goroutine 没有阻塞,同时读成功。
      fmt.Println("Locking")
      rwMutex.RLock()
      defer rwMutex.RUnlock()
      fmt.Printf("Read data: %v\n", Data)
      wg.Done()
      time.Sleep(2 * time.Second)
    }(i)
    go func(t int) {
      // 写锁定下是需要解锁后才能写的
      rwMutex.Lock()
      defer rwMutex.Unlock()
      Data += t
      fmt.Printf("Write Data: %v %d \n", Data, t)
      wg.Done()
      time.Sleep(2 * time.Second)
    }(i)
  }
  wg.Wait()
}
复制代码


总结


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


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


通道有三种:


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


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


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




文章中的脑图和源码都上传到了 GitHub,有需要的同学可自行下载。


地址:github.com/yongxinz/go…



目录
相关文章
|
4月前
|
存储 Go API
如何在 Go 中获取 goroutine 的 ID?
在 Go 语言中,Goroutine 是轻量级线程,但官方未提供直接获取 Goroutine ID 的 API,以避免开发者依赖其进行复杂操作。然而,在调试和日志跟踪时,获取 Goroutine ID 可能很有帮助。本文介绍了通过 `runtime.Stack` 解析调用栈信息提取 Goroutine ID 的方法,尽管性能较低,适合调试场景。同时推荐使用第三方包 `github.com/petermattis/goid`,它通过 C 和汇编实现更高效地获取 Goroutine ID。需要注意的是,Goroutine ID 不应用于业务逻辑,而应关注 Goroutine 行为与通道通信。
141 11
如何在 Go 中获取 goroutine 的 ID?
|
2月前
|
Go 开发者
Go语言实战案例:使用select监听多个channel
本文为《Go语言100个实战案例 · 网络与并发篇》第5篇,详解Go并发核心工具`select`的使用。通过实际案例讲解如何监听多个Channel、实现多任务处理、超时控制和非阻塞通信,帮助开发者掌握Go并发编程中的多路异步事件处理技巧。
|
2月前
|
数据采集 编解码 监控
Go语言实战案例:使用channel实现生产者消费者模型
本文是「Go语言100个实战案例 · 网络与并发篇」第4篇,通过实战案例详解使用 Channel 实现生产者-消费者模型,涵盖并发控制、任务调度及Go语言并发哲学,助你掌握优雅的并发编程技巧。
|
2月前
|
数据采集 消息中间件 编解码
Go语言实战案例:使用 Goroutine 并发打印
本文通过简单案例讲解 Go 语言核心并发模型 Goroutine,涵盖协程启动、输出控制、主程序退出机制,并结合 sync.WaitGroup 实现并发任务同步,帮助理解 Go 并发设计思想与实际应用。
|
4月前
|
数据采集 安全 Go
Go 语言并发编程基础:Goroutine 的创建与调度
Go 语言的 Goroutine 是轻量级线程,由 runtime 管理,具有启动快、占用小、支持高并发的特点。本章介绍 Goroutine 的基本概念、创建方式(如使用 `go` 关键字或匿名函数)、M:N 调度模型及其工作流程,并探讨其在高并发场景中的应用,帮助理解其高效并发的优势。
|
4月前
|
Go 开发者
Go 并发编程基础:无缓冲与有缓冲通道
本章深入探讨Go语言中通道(Channel)的两种类型:无缓冲通道与有缓冲通道。无缓冲通道要求发送和接收必须同步配对,适用于精确同步和信号通知;有缓冲通道通过内部队列实现异步通信,适合高吞吐量和生产者-消费者模型。文章通过示例对比两者的行为差异,并分析死锁风险及使用原则,帮助开发者根据场景选择合适的通道类型以实现高效并发编程。
|
存储 缓存 Java
浅析Go中Channel的各路用法
浅析Go中Channel的各路用法
31735 0
浅析Go中Channel的各路用法
|
Go
golang channel 用法转的
一、Golang并发基础理论 Golang在并发设计方面参考了C.A.R Hoare的CSP,即Communicating Sequential Processes并发模型理论。但就像John Graham-Cumming所说的那样,多数Golang程序员或爱好者仅仅停留在“知道”这一层次,理解CSP理论的并不多,毕竟多数程序员是搞工程 的。
1225 0