sync.waitGroup的wait可以多次wait，同時通知

最近讀groupcache的源碼，有個一次執行的模塊。

 

保證同一個key的函數只執行一次。

 

 

原理是利用sync.waitGroup的wait可以同步阻塞。然后等待所有的wait完成

 

寫了個測試的demo程序，其實還是需要分析下標准庫源碼。

wait是個for循環，檢測當前的狀態

 

for {
		state := atomic.LoadUint64(statep)
		v := int32(state >> 32)
		w := uint32(state)
		if v == 0 {
			// Counter is 0, no need to wait.
			if race.Enabled {
				race.Enable()
				race.Acquire(unsafe.Pointer(wg))
			}
			return
		}
		// Increment waiters count.
		if atomic.CompareAndSwapUint64(statep, state, state+1) {
			if race.Enabled && w == 0 {
				// Wait must be synchronized with the first Add.
				// Need to model this is as a write to race with the read in Add.
				// As a consequence, can do the write only for the first waiter,
				// otherwise concurrent Waits will race with each other.
				race.Write(unsafe.Pointer(semap))
			}
			runtime_Semacquire(semap)
			if *statep != 0 {
				panic("sync: WaitGroup is reused before previous Wait has returned")
			}
			if race.Enabled {
				race.Enable()
				race.Acquire(unsafe.Pointer(wg))
			}
			return
		}
	}

　　

 

 

如下是我的demo

 

package main

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


/*
測試多個wait的情況

*/
func main()  {
    fmt.Println("start")

    var group sync.WaitGroup

    group.Add(1)
    for i:=0; i< 10; i++{
        go func(i int){
            fmt.Printf("process %d waiting\n", i)
            group.Wait()
            fmt.Printf("process %d waiting done\n", i)
        }(i)
    }
    time.Sleep(time.Second * 1)
    group.Done()

    time.Sleep(time.Second * 1)

    fmt.Println("end")
}