学 Go 的时候知道 Go 语言支持并发,最简单的方法是通过 go 关键字开启 goroutine 即可。可在工作中,用的是 sync 包的 WaitGroup,然而这样还不够,当多个 goroutine 同时访问一个变量时,还要考虑如何保证这些 goroutine 之间不会相互影响,这就又使用到了 sync 的 Mutex。它们是如何串起来的呢?

一、Goroutinue

先说 goroutine,我们都知道它是 Go 中的轻量级线程。Go 程序从 main 包的 main() 函数开始,在程序启动时,Go 程序就会为 main() 函数创建一个默认的 goroutine。使用 goroutine,使用关键字 go 即可。

package main
import (
"fmt"
)
func main() {
// 并发执行程序
go running()
}
func running() {
fmt.Println("Goroutine")
}

执行代码会发现没有我们预期的“Goroutine”输出,这是因为当前的程序是一个单线程的程序,main 函数只要执行后,就不会再管其他线程在做什么事情,程序就自动退出了。解决办法是加一个 sleep 函数,让 main 函数等待 running 函数执行完毕后再退出。我们假设 running 函数里的代码执行需要 2 秒,因此让 main 函数等待 3 秒再退出。

package main
import (
"fmt"
"time"
)
func main() {
// 并发执行程序
go running()
time.Sleep(3 * time.Second)
}
func running() {
fmt.Println("Goroutine")
}

再次执行代码,终端输出了我们想要的“Goroutine”字符串。

二、WaitGroup

上面我们是假设了 running 函数执行需要 2 秒,可如果执行需要 10 秒甚至更长时间,不知道 goroutin 什么时候结束,难道还要 main 函数 sleep 更多的秒数吗?就不能让 running 函数执行完去通知 main 函数,main 函数收到信号自动退出吗?还真可以!可以使用 sync 包的 Waitgroup 判断一组任务是否完成。

WatiGroup 能够一直等到所有的 goroutine 执行完成,并且阻塞主线程的执行,直到所有的 goroutine 执行完成。它有 3 个方法:

  • Add():给计数器添加等待 goroutine 的数量。
  • Done():减少 WaitGroup 计数器的值,应在协程的最后执行。
  • Wait():执行阻塞,直到所有的 WaitGroup 数量变成 0

一个简单的示例如下:

package main
import (
"fmt”
"sync”
“time"
) func process(i int, wg *sync.WaitGroup) {
fmt.Println("started Goroutine ", i)
time.Sleep(2 * time.Second)
fmt.Printf("Goroutine %d ended\n", i)
wg.Done()
} func main() {
var wg sync.WaitGroup
for i := 0; i < 3; i++ {
wg.Add(1)
go process(i, &wg)
}
wg.Wait()
fmt.Println("All go routines finished executing”)
}
//main函数也可以写成如下方式
func main() {
var wg sync.WaitGroup
wg.Add(3) //设置计数器,数值即为goroutine的个数
go process(1, &wg)
go process(2, &wg)
go process(3, &wg)
wg.Wait() //主goroutine阻塞等待计数器变为0
fmt.Println("All goroutines finished executing")
}

命令行输出如下:

deer@192 src % go run hello.go //第1次
started Goroutine 3
started Goroutine 1
started Goroutine 2
Goroutine 2 ended
Goroutine 1 ended
Goroutine 3 ended
All goroutines finished executing deer@192 src % go run hello.go //第2次
started Goroutine 3
started Goroutine 1
started Goroutine 2
Goroutine 1 ended
Goroutine 2 ended
Goroutine 3 ended
All goroutines finished executing deer@192 src % go run hello.go //第3次
started Goroutine 3
started Goroutine 2
started Goroutine 1
Goroutine 3 ended
Goroutine 1 ended
Goroutine 2 ended
All goroutines finished executing

简单的说,上面程序中 wg 内部维护了一个计数器,激活了 3 个 goroutine:

1)每次激活 goroutine 之前,都先调用 Add() 方法增加一个需要等待的 goroutine 计数。

2)每个 goroutine 都运行 process() 函数,这个函数在执行完成时需要调用 Done() 方法来表示 goroutine 的结束。

3)激活 3 个 goroutine 后,main 的 goroutine 会执行到 Wait(),由于每个激活的 goroutine 运行的 process() 都需要睡眠 2 秒,所以 main 的 goroutine 在 Wait() 这里会阻塞一段时间(大约2秒),

4)当所有 goroutine 都完成后,计数器减为 0,Wait() 将不再阻塞,于是 main 的 goroutine 得以执行后面的 Println()。

这里需要注意:

1)process() 中使用指针类型的 *sync.WaitGroup 作为参数,表示这 3 个 goroutine 共享一个 wg,才能知道这 3 个 goroutine 都完成了。如果这里使用值类型的 sync.WaitGroup 作为参数,意味着每个 goroutine 都拷贝一份 wg,每个 goroutine 都使用自己的 wg,main goroutine将会永久阻塞而导致产生死锁。

2)Add() 设置的数量必须与实际等待的 goroutine 个数一致,也就是和Done的调用数量必须相等,否则会panic,报错信息如下:

fatal error: all goroutines are asleep - deadlock!

三、锁

当多个 goroutine 同时操作一个变量时,会存在数据竞争,导致最后的结果与期待的不符,解决办法就是加锁。Go 中的 sync 包 实现了两种锁:Mutex 和 RWMutex,前者为互斥锁,后者为读写锁,基于 Mutex 实现。当我们的场景是写操作为主时,可以使用 Mutex 来加锁、解锁。

var lock sync.Mutex //声明一个互斥锁
lock.Lock() //加锁
//code...
lock.Unlock() //解锁

互斥锁其实就是每个线程在对资源操作前都尝试先加锁,成功加锁才能操作,操作结束后再解锁。也就是说,使用了互斥锁,同一时刻只能有一个 goroutine 在执行。

Go的Waitgroup和锁的更多相关文章

  1. 10.Go-goroutine,waitgroup,互斥锁和channel

    10.1.goroutine goroutine的使用 //Learn_Go/main.go package main import ( "fmt" "time" ...

  2. 10.Go-goroutine,waitgroup,互斥锁,channel和select

    10.1.goroutine goroutine的使用 //Learn_Go/main.go package main import ( "fmt" "time" ...

  3. 限制goroutine数量写法

    虽然golang的goroutine可以开启无数个goroutine,但是没有限制也是不行的.我就写一下我对goroutine数量限制的写法 1.初始化goroutine协程池.把goroutine数 ...

  4. Go 笔记之如何防止 goroutine 泄露

    今天来简单谈谈,Go 如何防止 goroutine 泄露. 概述 Go 的并发模型与其他语言不同,虽说它简化了并发程序的开发难度,但如果不了解使用方法,常常会遇到 goroutine 泄露的问题.虽然 ...

  5. Go从入门到放弃(笔记存档)

    前言 考虑到印象笔记以后不续费了,这里转存到博客园一份 因内容是自己写的笔记, 未作任何润色, 所以看着很精简, 请见谅 查看官方文档 在新的go安装包中,为了减小体积默认去除了go doc 安装go ...

  6. Go语言 | 并发设计中的同步锁与waitgroup用法

    今天是golang专题的第16篇文章,我们一起来聊聊golang当中的并发相关的一些使用. 虽然关于goroutine以及channel我们都已经介绍完了,但是关于并发的机制仍然没有介绍结束.只有go ...

  7. Go 初体验 - 并发与锁.2 - sync.WaitGroup

    sync包里的WaitGroup主要用于协程同步 计数主协程创建的子线程 WaitGoup.Add(i) 调用清除标记方法WaitGroup.Done() 使用WaitGroup.Wait()来阻塞, ...

  8. Go并发控制之sync.WaitGroup

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

  9. Go基础之锁的初识

    当我们的程序就一个线程的时候是不需要用到锁的,但是通常我们实际的代码不会是单个线程的,所有这个时候就需要用到锁了,那么关于锁的使用场景主要涉及到哪些呢? 当我们多个线程在读相同的数据的时候则是需要加锁 ...

随机推荐

  1. Caused by: java.lang.RuntimeException: JxBrowser license check failed: No valid license found

    使用jxbrower报错,原因时证书检验失败, 解决方案: 1.首先创建证书,下面是我在IDEA maven项目中创建的位置,Java项目中在src/目录下创建, META-INF/teamdev.l ...

  2. Java学习之this关键字的使用

    •区分成员变量和局部变量 public class Person { String name; int age; public void set(String name,int age) { this ...

  3. redis的主从复制(哨兵模式)

    p.p1 { margin: 0; font: 10px ".SF NS Text" } Master以写为主,Slave以读为主 读写分离 容灾恢复 一.一主多从 配置文件修改: ...

  4. vue篇之路由详解

    一.vue路由传参的几种方式 1.声明式 router-link 父组件:<router-link :to="`/path/${id}`"><router-lin ...

  5. Dynamics CRM与ADFS安装到同一台服务器后ADFS服务与Dynamics CRM沙盒服务冲突提示808端口占用问题

    当我们安装Dynamics CRM的产品时如果是单台服务器部署而且部署了IFD的情况会遇到一个问题就是ADFS服务的监听端口和Dynamics CRM沙盒服务的端口冲突了. 这样会导致两个服务中的一个 ...

  6. MyBatis笔记(七)

    1. 简介 什么是缓存? 存在内存中的临时数据 将用户经常查询的数据存放在缓存(内存)中,用户取查询就不用从磁盘上(关系型数据库数据文件)查询,从缓存中查询,从而提高查询效率,解决了高并发系统的性能问 ...

  7. 记docker安装和ida远程调试问题

    docker安装 1.卸载可能存在的旧版本: sudo apt-get remove docker docker-engine docker-ce docker.io   如果想要彻底卸载docker ...

  8. 华为分析+App Linking:一站式解决拉新、留存、促活难

    移动互联网时代,用户注意力稀缺,"如何让用户一键直达APP特定页面"越来越受到产品和运营同学的关注. 比如在各个渠道投放了APP安装广告,希望新用户下载APP首次打开时直接进入活动 ...

  9. 奇异值分解(SVD)与主成分分析(PCA)

    本文中的内容来自我的笔记.撰写过程中,参考了书籍<统计学习方法(第2版)>和一些网络资料. 第一部分复习一些前置知识,第二部分介绍奇异值分解(SVD),第三部分介绍主成分分析(PCA).以 ...

  10. 使用nvm管理node.js版本以及更换npm淘宝镜像源

    目录 1,前言 2,安装nvm 3,nvm的使用 4,错误处理 5,修改npm默认镜像源 6,win10下cnpm报错 1,前言 注意:此教程仅限Windows,Mac可能不适用 在我们的日常开发中可 ...