Golang中 sync.Once 应用

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

Do方法
Once类型的Do方法只接收一个参数，参数的类型必须是func()，即无参数无返回的函数。该方法的功能并不是对每一种参数函数都只执行一次，而是只执行首次被调用时传入的那个函数，并且之后不会再执行任何参数函数。所以，如果有多个需要执行一次的函数，应该为它们每一个都分配一个sync.Once类型的值。

示例

var printPid sync.Once

func main() {
    listener, err := net.Listen("tcp", "localhost:18888")
    if err != nil {
        log.Fatal(err)
    }
    defer listener.Close()
    for {
        printPid.Do(func() {
            log.Println("process pid:", os.Getpid())
        })
        conn, err := listener.Accept()
        if err != nil {
            log.Println("监听端口发生错误", err)
        }
        log.Println(conn.RemoteAddr(), "连接成功")
        go handleConn(conn)
    }
}

• 输出

2018/03/24 11:48:24 process pid: 7992

源码

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

// Do calls the function f if and only if Do is being called for the
// first time for this instance of Once. In other words, given
//  var once Once
// if once.Do(f) is called multiple times, only the first call will invoke f,
// even if f has a different value in each invocation. A new instance of
// Once is required for each function to execute.
//
// Do is intended for initialization that must be run exactly once. Since f
// is niladic, it may be necessary to use a function literal to capture the
// arguments to a function to be invoked by Do:
//  config.once.Do(func() { config.init(filename) })
//
// Because no call to Do returns until the one call to f returns, if f causes
// Do to be called, it will deadlock.
//
// If f panics, Do considers it to have returned; future calls of Do return
// without calling f.
//
func (o *Once) Do(f func()) {
    if atomic.LoadUint32(&o.done) == 1 {
        return
    }
    // Slow-path.
    o.m.Lock()
    defer o.m.Unlock()
    if o.done == 0 {
        defer atomic.StoreUint32(&o.done, 1)
        f()
    }
}

源码，一把锁，一个flag进行标识。
先判断flag，如果已经为1，则直接返回。如果是0，则先加锁，然后把flag置为1，然后执行函数对象，最后解锁。