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(sync.WaitGroup)
    for i := 0; i < 3; i++ {
        wg.Add(1)
        go wgProcess(wg, i)
    }
    wg.Wait()
    fmt.Println("after wait group")
}

时间： 2024-11-16 17:40:28

golang sync.WaitGroup的相关文章

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

Go并发控制之sync.WaitGroup

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

golang sync.Mutex(2)

package main import ( "fmt" "sync" "time" ) type User struct { Name string Locker *sync.Mutex } func (u *User) SetName(wati *sync.WaitGroup, name string) { defer func() { fmt.Println("Unlock set name:", name) u.Lock

golang基础-WaitGroup、kafka消费者

kafka消费者以下博客是通过生产者创建.发送消息至kafka 博客链接现在我们站在消费者的角度,来进行收取消息 package main import ( "fmt" "strings" "sync" "github.com/Shopify/sarama" ) var ( wg sync.WaitGroup ) func main() { //创建消费者 consumer, err := sarama.NewConsum

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

sync.WaitGroup和sync.Once

sync.WaitGroup,顾名思义,等待一组goroutinue运行完毕.sync.WaitGroup声明后即可使用,它有如下方法: func (wg *WaitGroup) Add(delta int) #不能传入符数,否则引发panic func (wg *WaitGroup) Done() func (wg *WaitGroup) Wait() 一般套路是,"先统一Add, 在并发Done, 最后Wait".中心思想是由一个goroutine或主程序来调用Add和Wait方法

golang sync.RWMutex

sync.RWMutex package main import ( "fmt" "runtime" "sync" ) func clickWithMutex(total *int, m *sync.RWMutex, ch chan int) { for i := 0; i < 1000; i++ { m.Lock() *total += 1 m.Unlock() //这里是写下面是读,外层还有线程的竞争 if i == 500 { m.

golang sync.Pool包的使用和一些注意地方

package main; import ( "sync" "fmt" "net" "runtime" ) //sync.Pool是一个可以存或取的临时对象集合 //sync.Pool可以安全被多个线程同时使用,保证线程安全 //注意.注意.注意,sync.Pool中保存的任何项都可能随时不做通知的释放掉,所以不适合用于像socket长连接或数据库连接池. //sync.Pool主要用途是增加临时对象的重用率,减少GC负担.