Golang Sync.WaitGroup 使用及原理

使用

func main() {
var wg sync.WaitGroup
for i := 0; i < 10; i++ {
wg.Add(1)
go func() {
defer wg.Done()
fmt.Println("Hello WaitGroup!")
}()
}
wg.Wait()
}

实现

首先看 waitgroup 到底是什么数据结构

type WaitGroup struct {
noCopy noCopy
state1 [3]uint32
}

nocopy 避免这个结构体被复制的一个技巧,可以告诉go vet工具违反了复制使用的规则

state1 [3]uint32 字段中包含了 waitgroup 的所有状态信息, 根据标准库上自带的注释简单翻译是:state1 由 12 个字节组成,其中将8字节看作64位值,其中高32位存放的是 counter 计数器, 代表目前还未完成的 goroutine个数,低32位存放的是 waiter 计数器, 可以理解成下面这个结构体

type WaitGroup struct {
// 代表目前尚未完成的个数
// WaitGroup.Add(n) 将会导致 counter += n
// WaitGroup.Done() 将导致 counter--
counter uint32 // 目前已调用 WaitGroup.Wait 的 goroutine 的个数
waiter uint32 // 对应于 golang 中 runtime 内部的信号量的实现
// runtime_Semacquire 表示增加一个信号量,并挂起当前 goroutine
// runtime_Semrelease 表示减少一个信号量,并唤醒 sema 上其中一个正在等待的 goroutine
sema uint32
}

整个使用流程为:

  1. 当调用 WaitGroup.Add(n) 时,counter 将会自增: counter += n
  2. 当调用 WaitGroup.Wait() 时,会将 waiter++。同时调用 runtime_Semacquire(semap), 增加信号量,并挂起当前 goroutine。
  3. 当调用 WaitGroup.Done() 时,将会 counter--。如果自减后的 counter 等于 0,说明 WaitGroup 的等待过程已经结束,则需要调用 runtime_Semrelease 释放信号量,唤醒正在 WaitGroup.Wait 的 goroutine。

源码中是如何拆分 state 字段的

func (wg *WaitGroup) state() (statep *uint64, semap *uint32) {
if uintptr(unsafe.Pointer(&wg.state1))%8 == 0 {
// 如果地址是64bit对齐的,数组前两个元素做state,后一个元素做信号量
return (*uint64)(unsafe.Pointer(&wg.state1)), &wg.state1[2]
} else {
// 如果地址是32bit对齐的,数组后两个元素用来做state
// 它可以用来做64bit的原子操作,第一个元素32bit用来做信号量
return (*uint64)(unsafe.Pointer(&wg.state1[1])), &wg.state1[0]
}
}

由于我们能使用到的就是 waitgroup.Add(), waitgroup.Done(), waitgroup.Wait() 这三个方法,就按这三个方法分析

Add(), Done()

Add 方法主要操作的是 state 的计数部分。你可以为计数值增加一个 delta 值,内部通过原子操作把这个值加到计数值上。需要注意的是,这个 delta 也可以是个负数,相当于为计数值减去一个值,Done 方法内部其实就是通过 Add(-1) 实现的。

func (wg *WaitGroup) Add(delta int) {
// 获取拆开后的 state 字段
statep, semap := wg.state()
...
...
...
// 在刚刚说的 int64 的高32位上加伤传进来的 delta 的值, 这一步是原子操作
state := atomic.AddUint64(statep, uint64(delta)<<32)
// 加好后,获取 counter 也就是 v, 和 waiter 也就是 w 的值
// 此时 int64 变为两个 int32
v := int32(state >> 32)
w := uint32(state)
// 如果 v 变为负数了,程序异常
if v < 0 {
panic("sync: negative WaitGroup counter")
}
// 在 wait 没结束之前, 不允许调用 Add 方法
if w != 0 && delta > 0 && v == int32(delta) {
panic("sync: WaitGroup misuse: Add called concurrently with Wait")
} // 调用 add() 之后, 还有正在执行的 goroutine 或者 waiter 等于 0, 正常返回
if v > 0 || w == 0 {
return
}
// 下面就是非正常返回, 理解到的就是 v 已经等于 0 了,执行释放操作
// 首先就是将 counter 和 waiter 全部重置为 0
*statep = 0
// 然后循环调用还在等待的 waiter, 释放信号量
for ; w != 0; w-- {
runtime_Semrelease(semap, false, 0)
}
}

wait()

Wait 方法的实现逻辑是:不断检查 state 的值。如果其中的计数值变为了 0,那么说明所有的任务已完成,调用者不必再等待,直接返回。如果计数值大于 0,说明此时还有任务没完成,那么调用者就变成了等待者,需要加入 waiter 队列,并且阻塞住自己。

func (wg *WaitGroup) Wait() {
// 获取信号量和两个计数值
statep, semap := wg.state() // 不停的循环检查 counter 和 waiter
for {
// 先原子性的取出 counter 和 waiter
state := atomic.LoadUint64(statep)
v := int32(state >> 32)
w := uint32(state)
if v == 0 {
// counter 已经没有了,函数可以返回
return
}
// 将 waiter 数 + 1
if atomic.CompareAndSwapUint64(statep, state, state+1) {
// 放到信号量队列, 并且阻塞住自己
runtime_Semacquire(semap)
// 如果被唤醒,检查 两个计数是否已经为0 了, 如果不为0 ,则触发恐慌
if *statep != 0 {
panic("sync: WaitGroup is reused before previous Wait has returned")
}
// 函数返回
return
}
}
}

总结

  1. 保证计数器不能为负值
  2. 保证 Add() 方法全部调用完成之后再调用 Wait()
  3. waitgroup 可以重复使用
  4. atomic 原子操作代替锁, 提高并发性
  5. 合并两个 int32 为一个 int64 提高读取存入数据性能
  6. 对于不希望被复制的结构体, 可以使用 noCopy 字段

reference

https://www.cyhone.com/articles/golang-waitgroup/

https://time.geekbang.org/column/intro/100061801?tab=catalog

Golang Sync.WaitGroup 使用及原理的更多相关文章

  1. golang sync.WaitGroup

    //阻塞,直到WaitGroup中的所以过程完成. import ( "fmt" "sync" ) func wgProcess(wg *sync.WaitGr ...

  2. Golang sync.WaitGroup的用法

    0x01 介绍 经常会看到以下了代码: 12345678910111213 package main import ( "fmt" "time") func m ...

  3. golang sync.WaitGroup bug

    注意,这个结构体,要是想在函数之间传来传去的话,必须要使用指针....... 这个结构体里没有 指针,这个类型可以说没有“引用特性”. 被坑了一晚上.特此记录.

  4. golang-----golang sync.WaitGroup解决goroutine同步

    go提供了sync包和channel来解决协程同步和通讯.新手对channel通道操作起来更容易产生死锁,如果时缓冲的channel还要考虑channel放入和取出数据的速率问题. 从字面就可以理解, ...

  5. golang 的 sync.WaitGroup

    WaitGroup的用途:它能够一直等到所有的goroutine执行完成,并且阻塞主线程的执行,直到所有的goroutine执行完成. 官方对它的说明如下: A WaitGroup waits for ...

  6. Golang的sync.WaitGroup 实现逻辑和源码解析

    在Golang中,WaitGroup主要用来做go Routine的等待,当启动多个go程序,通过waitgroup可以等待所有go程序结束后再执行后面的代码逻辑,比如: func Main() { ...

  7. golang的sync.WaitGroup使用示例

    下面一段代码 len(m) 不一定会打印为 10,为什么?.如果想要 len(m) 打印为 10,应该怎么修改代码? func main() { const N = 10 m := make(map[ ...

  8. Go并发控制之sync.WaitGroup

    WaitGroup 会将main goroutine阻塞直到所有的goroutine运行结束,从而达到并发控制的目的.使用方法非常简单,真心佩服创造Golang的大师们! type WaitGroup ...

  9. Golang中WaitGroup使用的一点坑

    Golang中WaitGroup使用的一点坑 Golang 中的 WaitGroup 一直是同步 goroutine 的推荐实践.自己用了两年多也没遇到过什么问题.直到一天午睡后,同事扔过来一段奇怪的 ...

随机推荐

  1. Git 的配置 config

    Git 的配置 config Git 的配置 config config 文件简述 config 文件位置 信息查询 修改 config 文件 编辑配置文件 增加指定配置项 删除指定配置项 自助餐   ...

  2. WebGL 与 WebGPU 比对[1] 前奏

    目录 1 为什么是 WebGPU 而不是 WebGL 3.0 显卡驱动 图形 API 的简单年表 WebGL 能运行在各个浏览器的原因 WebGPU 的名称由来 2 与 WebGL 比较编码风格 Op ...

  3. Android官方文档翻译 十 2.3Styling the Action Bar

    Styling the Action Bar 设计菜单栏的样式 This lesson teaches you to 这节课教给你 Use an Android Theme 使用一个Android主题 ...

  4. ubuntu安装更换阿里云镜像源

    如果使用apt-get安装软件过慢,可以考虑以下步骤 1.备份 sudo cp /etc/apt/sources.list /etc/apt/sources.list.bak 2.编辑 sudo vi ...

  5. [开发笔记usbTOcan]系统架构设计

    SYS.3 | 系统架构设计 系统架构设计过程的目的是建立一个系统体系结构设计,并确定哪些系统需求分配给系统的哪些元素,并根据确定的标准评估系统架构. 系统结构设计需要做一下工作: 开发系统架构设计. ...

  6. Choregraphe 2.8.6.23动作失效

    动作和动画执行完以后,无法自动还原成默认状态,自然接下来动作无法执行了.之后各种操作可能诱发软件原有的bug.需要开关自主生活模块才能恢复. 部分连贯的动作不需要恢复就能执行,动画不行. 站立动作好像 ...

  7. 第03讲:Flink 的编程模型与其他框架比较

    Flink系列文章 第01讲:Flink 的应用场景和架构模型 第02讲:Flink 入门程序 WordCount 和 SQL 实现 第03讲:Flink 的编程模型与其他框架比较 本课时我们主要介绍 ...

  8. web下载文件的头消息

    resp.setHeader("Content-disposition","attachment;filename="+filename);

  9. 手把手教你用Strace诊断问题

    手把手教你用Strace诊断问题 发表于2015-10-16 早些年,如果你知道有个 strace 命令,就很牛了,而现在大家基本都知道 strace 了,如果你遇到性能问题求助别人,十有八九会建议你 ...

  10. 1.Flink实时项目前期准备

    1.日志生成项目 日志生成机器:hadoop101 jar包:mock-log-0.0.1-SNAPSHOT.jar gmall_mock ​ |----mock_common ​ |----mock ...