Go并发:使用sync.WaitGroup实现协程同步方式

经常看到有人会问如何等待主协程中创建的协程执行完毕之后再结束主协程，例如如下代码：

package main
import (
    "fmt"
)
func main() {
    go func() {
        fmt.Println("Goroutine 1")
    }()
    go func() {
        fmt.Println("Goroutine 2")
    }()
}

执行以上代码很可能看不到输出，因为有可能这两个协程还没得到执行主协程已经结束了，而主协程结束时会结束所有其他协程。

解决办法是可以在main函数结尾加上等待：

package main
import (
    "fmt"
    "time"
)
func main() {
    go func() {
        fmt.Println("Goroutine 1")
    }()
    go func() {
        fmt.Println("Goroutine 2")
    }()
    time.Sleep(time.Second * 1) // 睡眠1秒，等待上面两个协程结束
}

这并不是完美的解决方法，如果这两个协程中包含复杂的操作，可能很耗时间，就无法确定需要睡眠多久，当然可以用管道实现同步：

package main
import (
    "fmt"
)
func main() {
    ch := make(chan struct{})
    count := 2 // count 表示活动的协程个数
    go func() {
        fmt.Println("Goroutine 1")
        ch <- struct{}{} // 协程结束，发出信号
    }()
    go func() {
        fmt.Println("Goroutine 2")
        ch <- struct{}{} // 协程结束，发出信号
    }()
    for range ch {
        // 每次从ch中接收数据，表明一个活动的协程结束
        count--
        // 当所有活动的协程都结束时，关闭管道
        if count == 0 {
            close(ch)
        }
    }
}

上面的解决方案是比较完美的方案，但是Go提供了更简单的方法——使用sync.WaitGroup。

WaitGroup顾名思义，就是用来等待一组操作完成的。

WaitGroup内部实现了一个计数器，用来记录未完成的操作个数，它提供了三个方法，Add()用来添加计数。

Done()用来在操作结束时调用，使计数减一。

Wait()用来等待所有的操作结束，即计数变为0，该函数会在计数不为0时等待，在计数为0时立即返回。

package main
import (
    "fmt"
    "sync"
)
func main() {
    var wg sync.WaitGroup
    wg.Add(2) // 因为有两个动作，所以增加2个计数
    go func() {
        fmt.Println("Goroutine 1")
        wg.Done() // 操作完成，减少一个计数
    }()
    go func() {
        fmt.Println("Goroutine 2")
        wg.Done() // 操作完成，减少一个计数
    }()
    wg.Wait() // 等待，直到计数为0
}

可见用sync.WaitGroup是最简单的方式。

补充：Golang 中使用WaitGroup的那点坑

sync.WaitGroup对于Golang开发者来说并不陌生，其经常作为多协程之间同步的一种机制。用好它势必会让你事半功倍，但是一旦错用将引发问题。

关于WaitGroup的使用网上有很多例子，在此就不做介绍了，我想说的是我在项目中使用WaitGroup遇到的坑。

在项目中，因为服务器有同步需求， 所以直接使用了WaitGroup，但是未考虑使用场景，结果在项目上线之后，高峰期的时候客户端经常出现卡顿，经过多方查找，才发现如果使用WaitGroup的时候，未启动单独的goroutine，那么极有可能造成主线程的阻塞，

所以我做了下面的测试(测试中，我把WaitGroup置于协程内)：

import (
 "fmt"
 "sync"
 "time"
)

func main() {
    fmt.Println("main-1")
 testW()
 fmt.Println("main-2")
 time.Sleep(time.Duration(15) * time.Second)
}

func testW() {
 fmt.Println("testW-1")
 go func() {
  var wg sync.WaitGroup
  fmt.Println("testW-2")
  testW1(&wg)
  fmt.Println("testW-5")
  wg.Wait()
  fmt.Println("testW-6")
 }()
}

func testW1(wg *sync.WaitGroup) {
 wg.Add(1)
 fmt.Println("testW-3")
 time.AfterFunc(time.Second*5, func() {
  wg.Done()
 })
 fmt.Println("testW-4")
}

输出为：

main-1

testchan-1

main-2

testchan-2

testchan-3

testchan-4

testchan-5

// 过5秒

testchan-6

总结：

将WaitGroup用于goroutine内，不会导致主线程的阻塞，同样可以实现同步的效果。

以上为个人经验，希望能给大家一个参考，也希望大家多多支持我们。如有错误或未考虑完全的地方，望不吝赐教。

赞 (0)

相关推荐

  • golang协程池模拟实现群发邮件功能

    golang协程池模拟实现群发邮件功能

    比如批量群发邮件的功能 因为发送邮件是个比较耗时的操作, 如果是传统的一个个执行 , 总体耗时比较长 可以使用golang实现一个协程池 , 并行发送邮件 pool包下的pool.go文件 package pool import "log" //具体任务,可以传参可以自定义操作 type Task struct { Args interface{} Do func(interface{})error } //协程的个数 var Nums int //任务通道 var JobChanne

  • Go 如何批量修改文件名

    工作中遇到了批量修改文件名的情况,为此写了个小程序,以供日后方便查看. 用法: renamedirfiles.exe -d "E:\shared\图片素材\ps123_20121120_01\背景图片打包下载" -p "bg%d" 代码如下: package main import ( "flag" "fmt" "os" "path/filepath" ) func main() { /

  • Go递归修改文件名的实例代码

    Go递归修改文件名的实例代码

    在生活中我们往往有这样的需求,就是从网上找的文件资源经常包含了一些无用信息,而且在它的子目录下也同样存在,如果我们手动一个个的修改的话会特别麻烦,也特别耗时,我们可以考虑把这件事交给计算机来做. 如下图,我的桌面有一个名为dir[我爱你]的目录,而且这个目录下的子目录和文件都包含[我爱你],这个[我爱你]对于我们来说是完全无用的,我们可以用Go的文件操作库来递归对文件进行重命名,把不需要的名字替换为空 示例代码: package main import ( "bufio" "

  • SpringBoot整合MongoDB实现文件上传下载删除

    本文主要内容 MongoDB基础操作命令示例练习 MongoDB居于GridFSTemplate的文件上传.下载.删除等操作(工作重点使用) 1. 基础命令 创建的数据库名称:horse,创建的集合名称:blog # 创建数据库 use horse # 删除当前数据库[horse] db.dropDatebase() # 查看所有数据库 show dbs # 设置用户的角色和权限 db.createUser({user:"horse",pwd:"mongo123",

  • go build 通过文件名后缀实现不同平台的条件编译操作

    go build 通过文件名后缀实现不同平台的条件编译操作

    go build 可以通过标签或者文件名的后缀来提供条件编译,这里说下通过文件名的后缀来提供条件编译 文件命名约定可以在go build 包里找到详细的说明,简单来说,就是源文件包含后缀:_$GOOS.go,那么这个源文件只会在这个平台下编译,_$GOARCH.go也是如此. 这两个后缀可以结合在一起使用,但是要注意顺序:_$GOOS_$GOARCH.go,不能反过来用:_$GOARCH_$GOOS.go 例如下面截图,这些文件定义了对应不同平台下是否需要编译. 补充:Golang: 条件和循环

  • go等待一组协程结束的操作方式

    go提供了sync包和channel来解决协程同步和通讯. 方式1: sync.WaitGroup是等待一组协程结束,sync.WaitGroup只有3个方法,Add()添加一个计数,Done()减去一个计数,Wait()阻塞直到所有任务完成. package main import ( "fmt" "sync" "time" ) var wg sync.WaitGroup //定义一个同步等待的组 func task(i int){ fmt.P

  • Go并发:使用sync.WaitGroup实现协程同步方式

    经常看到有人会问如何等待主协程中创建的协程执行完毕之后再结束主协程,例如如下代码: package main import ( "fmt" ) func main() { go func() { fmt.Println("Goroutine 1") }() go func() { fmt.Println("Goroutine 2") }() } 执行以上代码很可能看不到输出,因为有可能这两个协程还没得到执行主协程已经结束了,而主协程结束时会结束所

  • Go 并发实现协程同步的多种解决方法

    go 简洁的并发 多核处理器越来越普及.有没有一种简单的办法,能够让我们写的软件释放多核的威力?是有的.随着Golang, Erlang, Scala等为并发设计的程序语言的兴起,新的并发模式逐渐清晰.正如过程式编程和面向对象一样,一个好的编程模式有一个极其简洁的内核,还有在此之上丰富的外延.可以解决现实世界中各种各样的问题.本文以GO语言为例,解释其中内核.外延. 前言 Java 中有一系列的线程同步的方法,go 里面有 goroutine(协程),先看下下面的代码执行的结果是什么呢? pac

  • python 单线程和异步协程工作方式解析

    在python3.4之后新增了asyncio模块,可以帮我们检测IO(只能是网络IO[HTTP连接就是网络IO操作]),实现应用程序级别的切换(异步IO).注意:asyncio只能发tcp级别的请求,不能发http协议. 异步IO:所谓「异步 IO」,就是你发起一个 网络IO 操作,却不用等它结束,你可以继续做其他事情,当它结束时,你会得到通知. 实现方式:单线程+协程实现异步IO操作. 异步协程用法 接下来让我们来了解下协程的实现,从 Python 3.4 开始,Python 中加入了协程的概

  • 一文详解go同步协程的必备工具WaitGroup

    目录 1. 简介 2. 基本使用 2.1 定义 2.2 使用方式 2.3 使用例子 3.实现原理 3.1 设计初衷 3.2 基本原理 3.3 代码实现 3.3.1 Add方法 3.3.2 Done方法实现 3.3.3 Wait方法实现 3.4 实现补充 4.使用注意事项 4.1 Add方法和Done方法需要成对出现 4.2 在所有任务都已经添加之后,才调用Wait方法进行等待 5. WaitGroup常见使用场景 总结 1. 简介 本文将介绍 Go 语言中的 WaitGroup 并发原语,包括

  • Go语言协程处理数据有哪些问题

    目录 前言 一.Goroutine 二.sync.WaitGroup 三.数据排序 四.限制协程数 五.协程Panic处理 总结 前言 我们在开发后台项目常常会遇到一个情况,功能模块列表数据导出Excel功能,但列表中某个字段无法通过Sql联表查询,且一次性查询再匹对也不方便:此时对列表数据循环,再一个个查询结果加入列表,势必需要很长的时间,我们该怎么才能提升下载速度呢? (这里采用Go开发服务端) 一.Goroutine 当然第一个想到可能是采用协程处理循环里面要查询的数据 type Card

  • python 协程并发数控制

    目录 多线程之信号量 协程中使用信号量控制并发 aiohttp 中 TCPConnector 连接池 前言: 本篇博客要采集的站点:[看历史,通天下-历史剧网] 目标数据是该站点下的热门历史事件,列表页分页规则如下所示: http://www.lishiju.net/hotevents/p0 http://www.lishiju.net/hotevents/p1 http://www.lishiju.net/hotevents/p2 首先我们通过普通的多线程,对该数据进行采集,由于本文主要目的是

  • Kotlin协程Job生命周期结构化并发详解

    Kotlin协程Job生命周期结构化并发详解

    目录 1.Job的生命周期 2.Deffered 3.Job与结构化并发 4.launch和async的使用场景 前面在学习协程启动方式的时候在launch的源码中有一个返回值是Job,async的返回Deferred也是实现了Job,那么而也就是说launch和async在创建一个协程的时候也会创建一个对应的Job对象.还提到过Job是协程的句柄,那么Job到底是什么?它有什么用? 1.Job的生命周期 先看一下Job的源码,这里只保留了跟标题相关的内容 public interface Jo

  • golang协程池设计详解

    Why Pool go自从出生就身带"高并发"的标签,其并发编程就是由groutine实现的,因其消耗资源低,性能高效,开发成本低的特性而被广泛应用到各种场景,例如服务端开发中使用的HTTP服务,在golang net/http包中,每一个被监听到的tcp链接都是由一个groutine去完成处理其上下文的,由此使得其拥有极其优秀的并发量吞吐量 for { // 监听tcp rw, e := l.Accept() if e != nil { ....... } tempDelay = 0

  • 详解php协程知识点

    多任务 (并行和并发) 在讲协程之前,先谈谈多进程.多线程.并行和并发. 对于单核处理器,多进程实现多任务的原理是让操作系统给一个任务每次分配一定的 CPU 时间片,然后中断.让下一个任务执行一定的时间片接着再中断并继续执行下一个,如此反复. 由于切换执行任务的速度非常快,给外部用户的感受就是多个任务的执行是同时进行的. 多进程的调度是由操作系统来实现的,进程自身不能控制自己何时被调度,也就是说: 进程的调度是由外层调度器抢占式实现的 而协程要求当前正在运行的任务自动把控制权回传给调度器,这样就

随机推荐