GOLANG sync.Once

对于从全局的角度只需要运行一次的代码，比如全局初化操始作，go语言提供了一个Once类型来保证全局的唯一性操作。

type Once

Once is an object that will perform exactly one action.

type Once struct {
    // contains filtered or unexported fields
}

func (*Once) Do

func (o *Once) Do(f func())

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.

大体意思是说，一个Once对象在全局范围内只会执行一个操作。

e.g. 单线程环境下演示Once的唯一性

package main

import (

    "fmt"

    "sync"

)

func f1() {

    fmt.Println("This is f1 function")

}

func f2() {

    fmt.Println("This is f2 function")

}

func f3() {

    fmt.Println("This is f3 function")

}

func main() {

    var once sync.Once

    once.Do(f1)

    once.Do(f2)

    once.Do(f3)

}

运行：

C:/go/bin/go.exe run test.go [E:/project/go/lx/src]

This is f1 function

成功: 进程退出代码 0.

从上面的运行结果可以看出，只有f1函数被调用了。一旦一个Once对象的Do方法被调用，那么接下来对该Once对象Do方法的调用都将不会执行。

e.g.多线程环境下演示Once的唯一性

package main

import (

    "fmt"

    "sync"

    "time"

)

var a string

var once sync.Once

func setup() {

    fmt.Println("setup begins.")

    a = "hello"

    for i := 1; i <= 10; i++ {

        time.Sleep(1e9)

        fmt.Print(".")

    }

    fmt.Println("\nsetup ends.")

}

func print(wg *sync.WaitGroup) {

    once.Do(setup)

    fmt.Println(a)

    wg.Done()

}

func main() {

    var wg sync.WaitGroup

    wg.Add(2)

    go print(&wg)

    go print(&wg)

    wg.Wait()

}

运行：

C:/go/bin/go.exe run test2.go [E:/project/go/lx/src]

setup begins.

..........

setup ends.

hello

hello

成功: 进程退出代码。

这里需要说明一点：在首次调用once.Do()方法时，其内部会加锁，阻塞其他goroutine对此Do方法的调用，直至全局唯一性操作调用结束，才会释放内部的锁。