Go之sync.Once

作用：sync.Once能确保实例化对象Do方法在多线程环境只运行一次,内部通过互斥锁实现。

比如，某个操作只需要做一次，在多个goroutine同时操作的时候，保证只操作一次，不会重复操作。

sync.Once表示只执行一次函数。要做到这点，就需要两点：

（1）计数器，统计函数执行次数；

（2）线程安全，保障在多G情况下，函数仍然只执行一次，比如锁。

示例1：

一个线程安全的单例模式

package singleton

import (
    "fmt"
    "sync"
)

type object struct {
    name string
}

var once sync.Once
var obj *object //单例指针

//公开方法 外包调用
func Instance() *object {
    once.Do(getObj)
    return obj
}

func getObj() {
    if obj == nil {
        obj = new(object)
        //可以做其他初始化事件
    }
}

//单例测试
func (obj *object) Test() {
    fmt.Println(obj.name)
}

示例2：

尽管for循环每次都会调用once.Do()方法，但是函数onceBody()却只会被执行一次。 

package main

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

var once sync.Once
var onceBody = func() {
    fmt.Println("Only once")
}

func main() {
        for i := 0; i < 10; i++ {
                go func(i int) {
                        once.Do(onceBody)
                        fmt.Println("i=",i)
                }()
        }
        time.Sleep(time.Second) //睡眠1s用于执行go程，注意睡眠时间不能太短
}

Do方法相当简单，但是也是有可以学习的地方。比如一些标志位可以通过原子操作表示，避免加锁，提高性能。

Do方法实现过程如下：

（1）首先原子load函数执行次数，如果已经执行过了，就return；

（2）lock；

（3）执行函数；

（4）原子store函数执行次数1；

（5）unlock。

sync.Once的定义：

// Once is an object that will perform exactly one action.
type Once struct {
    m    Mutex
    done uint32
}

//使用了双层检查机制 
func (o *Once) Do(f func()) {
    if atomic.LoadUint32(&o.done) == 1 {
        return
    }
    // Slow-path.
    o.m.Lock()
    defer o.m.Unlock()
    //这里需要再次重新判断下，因为 atomic.LoadUint32取出状态值到  o.m.Lock() 之间是有可能存在其它gotoutine改变status的状态值的
    if o.done == 0 {
        f()
        atomic.StoreUint32(&o.done, 1)
    }
}