[TOC] ## 語法 ### Type ``` type Cond func NewCond(l Locker) *Cond func (c *Cond) Broadcast() func (c *Cond) Signal() func (c *Cond) Wait() type Locker type Map func (m *Map) Delete(key interface{}) func (m *Map) Load(key interface{}) (value interface{}, ok bool) func (m *Map) LoadAndDelete(key interface{}) (value interface{}, loaded bool) func (m *Map) LoadOrStore(key, value interface{}) (actual interface{}, loaded bool) func (m *Map) Range(f func(key, value interface{}) bool) func (m *Map) Store(key, value interface{}) type Mutex func (m *Mutex) Lock() func (m *Mutex) Unlock() func (m *Mutex) TryLock() type Once func (o *Once) Do(f func()) type Pool func (p *Pool) Get() interface{} func (p *Pool) Put(x interface{}) type RWMutex func (rw *RWMutex) Lock() func (rw *RWMutex) RLock() func (rw *RWMutex) RLocker() Locker func (rw *RWMutex) RUnlock() func (rw *RWMutex) Unlock() type WaitGroup func (wg *WaitGroup) Add(delta int) func (wg *WaitGroup) Done() func (wg *WaitGroup) Wait() ``` ## mutex.TryLock 嘗試加鎖，加鎖成功執行后續流程，如果加鎖失敗的話也不會阻塞，而會直接返回加鎖的結果 ``` func main() { var count = 0 var mu sync.Mutex wg := sync.WaitGroup{} wg.Add(1000) for i := 0; i < 1000; i++ { go func() { defer wg.Done() if mu.TryLock() { count++ mu.Unlock() } else { fmt.Printf("%+v\n", "lock failed") } }() } wg.Wait() fmt.Printf("%+v\n", count) //output: //lock failed //lock failed //lock failed //lock failed //lock failed //995 } ``` ## sync.Map - 并發安全的 map * 官方提供的并發安全的map * 底層通分離讀寫map和原子指令來實現讀的近似無鎖，并通過延遲更新的方式來保證讀的無鎖化 ``` errorMap := &sync.Map{} errorMap.Store(key, value) //更新或者新增 errorMap.Load(key) //取 errorMap.delete(key)//刪 errorMap.Range(function(k,v interface{})bool{//todo }) //遍歷 ``` ## sync.WaitGroup - 并發組 ``` var wg sync.WaitGroup for i := 0; i <= 10; i++ { wg.Add(1) go func(i int) { defer wg.Done() fmt.Printf("loop i is - %d\n", i) }(i) } wg.Wait() ``` ## sync.Pool - 對象池 [參考](https://www.haohongfan.com/post/2019-05-26-sync-pool/) - pool中的對象生命周期是兩次gc之間 - 池子中的每一個對象都可以相互替代 - pool里的對象隨時都有可能被自動移除，并且沒有任何通知。sync.Pool的數量是不可控制的 - 協程安全 - sync.Pool 的大小是可伸縮的，高負載時會動態擴容，存放在池中的對象如果不活躍了會被自動清理。 ``` var messagePool = sync.Pool{ New: func() interface{} { return Message{} }, } type Message struct { buf []byte op string } func NewMessage() *Message { return messagePool.Get().(*Message) } func (p *Message) Free() { p.buf = p.buf[:0] p.op = "" messagePool.Put(p) } ``` ## sync.Once - 只初始化一次即單例模式 ### 初始化 如果沒有初始化條件, ``` var myOnlyInstance = newMyType() ``` 有初始化條件 good ``` var ( once = sync.Once{} p string p1 string ) func init() { once.Do(func() { p="12" p1="13" }) } ``` ### 關閉操作 件被重復關閉會報error，而 channel 被重復關閉報 panic ``` package exec type closeOnce struct { *os.File once sync.Once err error } func (c *closeOnce) Close() error { c.once.Do(c.close) return c.err } func (c *closeOnce) close() { c.err = c.File.Close() } ``` ## sync.Cond - 當共享資源的狀態發生變化的時候，它可以用來通知被互斥鎖阻塞的 goroutine - sync.Cond 經常用在多個 goroutine 等待，一個 goroutine 通知（事件發生）的場景 - 如果是一個通知，一個等待，使用互斥鎖或 channel 就能搞定了 ``` var done = false func read(name string, c *sync.Cond) { c.L.Lock() for !done { c.Wait() } log.Println(name, "starts reading") c.L.Unlock() } func write(name string, c *sync.Cond) { time.Sleep(time.Second) c.L.Lock() done = true c.L.Unlock() log.Println(name, "wakes all") c.Broadcast() } func main() { cond := sync.NewCond(&sync.Mutex{}) go read("reader1", cond) go read("reader2", cond) go read("reader3", cond) write("writer", cond) time.Sleep(time.Second * 3) } ```