sync.WaitGroup和sync.Once

sync.WaitGroup,顾名思义,等待一组goroutinue运行完毕。sync.WaitGroup声明后即可使用,它有如下方法:

  1. func (wg *WaitGroup) Add(delta int) #不能传入符数,否则引发panic
  2. func (wg *WaitGroup) Done()
  3. func (wg *WaitGroup) Wait()

    一般套路是,"先统一Add, 在并发Done, 最后Wait"。中心思想是由一个goroutine或主程序来调用Add和Wait方法,其他goroutinue作为子任务调用done方法,否则会引发可能的panic异常。

sync.Once, 也是开箱即用的,声明后即可使用,只有一个方法:

  1. func (o *Once) Do(f func())

sync.Once需要注意以下两点,避免踩坑:

  1. 当多个goroutinue并发地调用同一个sync.Once实例时,如果传入的函数执行时间过长,由于sync.Once是使用锁机制,保证传入的函数只执行一次,因此会造成其他goroutinue函数的阻塞。
  2. sync.Once 有一个done的unint32的字段,取值只有0和1。只要Do方法执行完成,done就由0变为1。值得注意的是done由defer保证执行后一定会是1。
package main
import "sync"
import "fmt"
import "sync/atomic"
import "time"

const PI = 3.14
var w sync.WaitGroup
var once sync.Once
var doneTaskCount int32

func calCircleCircum(r float64, ret *float64) {
  defer w.Done()
  *ret = PI * r
  atomic.AddInt32(&doneTaskCount, 1)
  time.Sleep(time.Millisecond * 2000)
}

func calRectangleCircum(width float64, long float64, ret *float64) {
  defer w.Done()
  *ret = 2 * (long + width)
  atomic.AddInt32(&doneTaskCount, 1)
  time.Sleep(time.Millisecond * 1000)
}

func printResults(circleRet *float64, rectangleRet *float64) {

  once.Do(func(){
    for atomic.LoadInt32(&doneTaskCount) !=2 {
      fmt.Println("Wait sub task done.....")
      time.Sleep(time.Millisecond * 200)
    }
  })

  fmt.Printf("the cicle circumference is %1.2f\n", *circleRet)
  fmt.Printf("the rectangle circumference is %1.2f\n", *rectangleRet)
}

func main() {
  circleRet := 0.0
  rectangleRet := 0.0

  w.Add(2)
  go printResults(&circleRet, &rectangleRet)
  go calCircleCircum(2.0, &circleRet)
  go calRectangleCircum(2.0, 3.0, &rectangleRet)
  w.Wait()
}

原文地址:https://www.cnblogs.com/linyihai/p/10285437.html

时间: 2024-10-02 00:17:38

sync.WaitGroup和sync.Once的相关文章

Go sync.WaitGroup 等待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 calls Done when finished. At the same time,// Wait can be used to bloc

Go并发控制之sync.WaitGroup

WaitGroup 会将main goroutine阻塞直到所有的goroutine运行结束,从而达到并发控制的目的.使用方法非常简单,真心佩服创造Golang的大师们! type WaitGroup               //相当于一个箱子,将main goroutine 保护到里面 func (*WaitGroup) Add   //调用一次为箱子加一把锁(当然,你愿意也可以多把) func (*WaitGroup) Done  // 调用一次开一把锁(only one!) func

golang sync.WaitGroup

//阻塞,直到WaitGroup中的所以过程完成. import ( "fmt" "sync" ) func wgProcess(wg *sync.WaitGroup, id int) { fmt.Printf("process:%d is going!\n", id) //if id == 2 { // return //} wg.Done() } func main() { //var wg sync.WaitGroup wg := new(

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的sync.WaitGroup 实现逻辑和源码解析

在Golang中,WaitGroup主要用来做go Routine的等待,当启动多个go程序,通过waitgroup可以等待所有go程序结束后再执行后面的代码逻辑,比如: func Main() { wg := sync.WaitGroup{} for i := 0; i < 10; i++ { wg.Add(1) go func() { defer wg.Done() time.Sleep(10 * time.Second) }() } wg.Wait() // 等待在此,等所有go func

golang 中 sync.Mutex 和 sync.RWMutex

介绍 golang 中的 sync 包实现了两种锁: Mutex:互斥锁 RWMutex:读写锁,RWMutex 基于 Mutex 实现 Mutex(互斥锁) Mutex 为互斥锁,Lock() 加锁,Unlock() 解锁 在一个 goroutine 获得 Mutex 后,其他 goroutine 只能等到这个 goroutine 释放该 Mutex 使用 Lock() 加锁后,不能再继续对其加锁,直到利用 Unlock() 解锁后才能再加锁 在 Lock() 之前使用 Unlock() 会导

go语言sync包的学习(Mutex、WaitGroup、Cond)

package main; import ( "fmt" "sync" "runtime" "time" ) //加锁,注意锁要以指针的形式传进来,不然只是拷贝 func total1(num *int, mu *sync.Mutex, ch chan bool) { mu.Lock(); for i := 0; i < 1000; i++ { *num += i; } ch <- true; mu.Unlock(

Go语言sync库和WaitGroup的使用

// code_041_sync_WaitGroup project main.go package main import ( "fmt" "sync" ) func main() { fmt.Println("Hello World!") var wg sync.WaitGroup wg.Add(2) go func() { defer wg.Done() for i := 0; i < 10000; i++ { fmt.Printf(

Docker Daemon启动

Docker Daemon 是Docker架构中运行在后台的守护进程,可分为Docker Server.Engine和Job三部分. Docker Daemon 是通过Docker Server模块接受Docker Client的请求,并在Engine中处理请求,然后根据请求类型,创建出指定的Job并运行,运行过程的几种可能:向Docker Registry获取镜像,通过graphdriver执行容器镜像的本地化操作,通过networkdriver执行容器网络环境的配置,通过execdriver