sync 包——Once

Once 的使用

sync.One一般用来确保某个动作至多执行一次。普遍用于初始化资源、单例模式。

单例模式的实现：

type MyBusiness interface {
	DoSomething()
}

// singleton 单例模式（一般与接口一起使用）
type singleton struct {
}

func (s singleton) DoSomething() {
	//TODO implement me
	panic("implement me")
}

var instance *singleton
var singletonOnce sync.Once

// GetSingleton 属于懒加载
func GetSingleton() MyBusiness {
	singletonOnce.Do(func() {
		instance = &singleton{}
	})
	return instance
}

// init 属于饥饿模式
func init() {
	// 用包初始化函数取代 One
	instance = &singleton{}
}

Once 的实现

// Once is an object that will perform exactly one action.
//
// A Once must not be copied after first use.
//
// In the terminology of the Go memory model,
// the return from f “synchronizes before”
// the return from any call of once.Do(f).
type Once struct {
   // done indicates whether the action has been performed.
   // It is first in the struct because it is used in the hot path.
   // The hot path is inlined at every call site.
   // Placing done first allows more compact instructions on some architectures (amd64/386),
   // and fewer instructions (to calculate offset) on other architectures.
   done uint32
   m    Mutex
}

Once 使用的也是 double-check 的变种 ，没有直接利用读写锁，而是利用原子操作来扮演读锁的角色。

func (o *Once) Do(f func()) {
   // Note: Here is an incorrect implementation of Do:
   //
   // if atomic.CompareAndSwapUint32(&o.done, 0, 1) {
   //    f()
   // }
   //
   // Do guarantees that when it returns, f has finished.
   // This implementation would not implement that guarantee:
   // given two simultaneous calls, the winner of the cas would
   // call f, and the second would return immediately, without
   // waiting for the first's call to f to complete.
   // This is why the slow path falls back to a mutex, and why
   // the atomic.StoreUint32 must be delayed until after f returns.

   if atomic.LoadUint32(&o.done) == 0 {
      // Outlined slow-path to allow inlining of the fast-path.
      o.doSlow(f)
   }
}

func (o *Once) doSlow(f func()) {
   o.m.Lock()
   defer o.m.Unlock()
   if o.done == 0 {
      defer atomic.StoreUint32(&o.done, 1)
      f()
   }
}