解析Go的Waitgroup和锁的问题
学 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 executingdeer@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 executingdeer@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和锁的问题的详细内容，更多关于Go的Waitgroup和锁的资料请关注我们其它相关文章！
相关推荐
-
GO语言并发编程之互斥锁、读写锁详解
在本节,我们对Go语言所提供的与锁有关的API进行说明.这包括了互斥锁和读写锁.我们在第6章描述过互斥锁,但却没有提到过读写锁.这两种锁对于传统的并发程序来说都是非常常用和重要的. 一.互斥锁 互斥锁是传统的并发程序对共享资源进行访问控制的主要手段.它由标准库代码包sync中的Mutex结构体类型代表.sync.Mutex类型(确切地说,是*sync.Mutex类型)只有两个公开方法--Lock和Unlock.顾名思义,前者被用于锁定当前的互斥量,而后者则被用来对当前的互斥量进行解锁. 类型sy
-
Go语言WaitGroup使用时需要注意的坑
前言 WaitGroup在go语言中,用于线程同步,单从字面意思理解,wait等待的意思,group组.团队的意思,WaitGroup就是指等待一组,等待一个系列执行完成后才会继续向下执行.Golang 中的 WaitGroup 一直是同步 goroutine 的推荐实践.自己用了两年多也没遇到过什么问题. 直到最近的一天同事扔过来一段奇怪的代码: 第一个坑 复制代码 代码如下: package main import ( "log" "sync&qu
-
Go并发:使用sync.WaitGroup实现协程同步方式
经常看到有人会问如何等待主协程中创建的协程执行完毕之后再结束主协程,例如如下代码: package main import ( "fmt" ) func main() { go func() { fmt.Println("Goroutine 1") }() go func() { fmt.Println("Goroutine 2") }() } 执行以上代码很可能看不到输出,因为有可能这两个协程还没得到执行主协程已经结束了,而主协程结束时会结束所
-
Golang中的sync包的WaitGroup操作
sync的waitgroup功能 WaitGroup 使用多线程时,进行等待多线程执行完毕后,才可以结束函数,有两个选择 channel waitgroup 首先使用channel func add (n *int , isok chan bool){ for i :=0 ;i <1000 ; i ++ { *n = *n + 1 } isok <- true } func main () { var ok = make(chan bool , 2) var i,u = 0,0 go add(
-
Django框架中数据的连锁查询和限制返回数据的方法
连锁查询 通常我们需要同时进行过滤和排序查询的操作. 因此,你可以简单地写成这种"链式"的形式: >>> Publisher.objects.filter(country="U.S.A.").order_by("-name") [<Publisher: O'Reilly>, <Publisher: Apress>] 你应该没猜错,转换成SQL查询就是 WHERE 和 ORDER BY 的组合: SELEC
-
Golang中的sync.WaitGroup用法实例
WaitGroup的用途:它能够一直等到所有的goroutine执行完成,并且阻塞主线程的执行,直到所有的goroutine执行完成. 官方对它的说明如下: A WaitGroup waits for a collection of goroutines to finish. The main goroutine calls Add to set the number of goroutines to wait for. Then each of the goroutines runs and
-
解决Golang 中使用WaitGroup的那点坑
sync.WaitGroup对于Golang开发者来说并不陌生,其经常作为多协程之间同步的一种机制.用好它势必会让你事半功倍,但是一旦错用将引发问题. 关于WaitGroup的使用网上有很多例子,在此就不做介绍了,我想说的是我在项目中使用WaitGroup遇到的坑. 在项目中,因为服务器有同步需求, 所以直接使用了WaitGroup,但是未考虑使用场景,结果在项目上线之后,高峰期的时候客户端经常出现卡顿,经过多方查找,才发现如果使用WaitGroup的时候,未启动单独的goroutine,那么极
-
解析Go的Waitgroup和锁的问题
学 Go 的时候知道 Go 语言支持并发,最简单的方法是通过 go 关键字开启 goroutine 即可.可在工作中,用的是 sync 包的 WaitGroup,然而这样还不够,当多个 goroutine 同时访问一个变量时,还要考虑如何保证这些 goroutine 之间不会相互影响,这就又使用到了 sync 的 Mutex.它们是如何串起来的呢? 一.Goroutinue 先说 goroutine,我们都知道它是 Go 中的轻量级线程.Go 程序从 main 包的 main() 函数开始,在程
-
解析Java编程之Synchronized锁住的对象
图片上传 密码修改为 synchronized是java中用于同步的关键字,一般我们通过Synchronized锁住一个对象,来进行线程同步.我们需要了解在程序执行过程中,synchronized锁住的到底是哪个对象,否则我们在多线程的程序就有可能出现问题. 看下面的代码,我们定义了一个静态变量n,在run方法中,我们使n增加10,然后在main方法中,我们开辟了100个线程,来执行n增加的操作,如果线程没有并发执行,那么n最后的值应该为1000,显然下面的程序执行完结果不是1000,因为我们
-
Java源码解析之可重入锁ReentrantLock
本文基于jdk1.8进行分析. ReentrantLock是一个可重入锁,在ConcurrentHashMap中使用了ReentrantLock. 首先看一下源码中对ReentrantLock的介绍.如下图.ReentrantLock是一个可重入的排他锁,它和synchronized的方法和代码有着相同的行为和语义,但有更多的功能.ReentrantLock是被最后一个成功lock锁并且还没有unlock的线程拥有着.如果锁没有被别的线程拥有,那么一个线程调用lock方法,就会成功获取锁并返回.
-
解析Java多线程之常见锁策略与CAS中的ABA问题
目录 1.常见的锁策略 1.1乐观锁与悲观锁 1.2读写锁与普通互斥锁 1.3重量级锁与轻量级锁 1.4挂起等待锁与自旋锁 1.5公平锁与非公平锁 1.6可重入锁与不可重入锁 1.7死锁问题 1.7.1常见死锁的情况 1.7.2哲学家就餐问题 2.CAS指令与ABA问题 2.1CAS指令 2.2ABA问题 本篇文章将介绍常见的锁策略以及CAS中的ABA问题,前面介绍使用synchronized关键字来保证线程的安全性,本质上就是对对象进行加锁操作,synchronized所加的锁到底是什么类型的
-
Java面向对象编程（封装/继承/多态）实例解析
本文主要介绍了面向对象的三大特征实例解析,下面看看具体内容. 封装 封装一个Teacher和Student类 package com.hz.test; public class Teacher { private String name; private String majorDirection; private String teachCourse; private int teachAge; public Teacher() { super(); } public Teacher(Stri
-
一篇文章就能了解Rxjava
前言: 第一次接触RxJava是在前不久,一个新Android项目的启动,在评估时选择了RxJava.RxJava是一个基于事件订阅的异步执行的一个类库.听起来有点复杂,其实是要你使用过一次,就会大概明白它是怎么回事了!为是什么一个Android项目启动会联系到RxJava呢?因为在RxJava使用起来得到广泛的认可,又是基于Java语言的.自然会有善于组织和总结的开发者联想到Android!没错,RxAndroid就这样在RxJava的基础上,针对Android开发的一个库.今天我们主要是来讲
-
Java编程synchronized与lock的区别【推荐】
前言 本文介绍了Java编程synchronized与lock的区别的相关内容,如果您对synchronized与lock不太了解,这两篇文章 或许是不错的选择: Java 同步锁(synchronized)详解及实例 Java多线程基础--Lock类 正文 从Java 5之后,在java.util.concurrent.locks包下提供了另外一种方式来实现同步访问,那就是Lock. 也许有朋友会问,既然都可以通过synchronized来实现同步访问了,那么为什么还需要提供Lock?这个问题
-
Java多线程饥饿与公平介绍及代码示例
如果一个线程因为CPU时间全部被其他线程抢走而得不到CPU运行时间,这种状态被称之为"饥饿".而该线程被"饥饿致死"正是因为它得不到CPU运行时间的机会.解决饥饿的方案被称之为"公平性" – 即所有线程均能公平地获得运行机会. 下面是本文讨论的主题: Java中导致饥饿的原因 在Java中,下面三个常见的原因会导致线程饥饿: 高优先级线程吞噬所有的低优先级线程的CPU时间. 线程被永久堵塞在一个等待进入同步块的状态,因为其他线程总是能在它之前持续
-
java代码块之简易qq登录界面及按钮颜色设置代码
本文主要分享了关于简洁版qq登录界面及按钮颜色设置的相关代码,供参考. java代码块 公共包(初始化窗口位置) package util; import java.awt.Dimension; import java.awt.Toolkit; import javax.swing.JFrame; //图形化界面的工具类 public class FrameUtil { //设置窗体出现在中间位置 public static void initFrame(JFrame frame,int wid
-
Go 防止 goroutine 泄露的方法
概述 Go 的并发模型与其他语言不同,虽说它简化了并发程序的开发难度,但如果不了解使用方法,常常会遇到 goroutine 泄露的问题.虽然 goroutine 是轻量级的线程,占用资源很少,但如果一直得不到释放并且还在不断创建新协程,毫无疑问是有问题的,并且是要在程序运行几天,甚至更长的时间才能发现的问题. 对于上面描述的问题,我觉得可以从两方面入手解决,如下: 一是预防,要做到预防,我们就需要了解什么样的代码会产生泄露,以及了解如何写出正确的代码: 二是监控,虽说预防减少了泄露产生的概率,但