go并发利器sync.Once使用示例详解

var once sync.Once
func initOperation() {
    // 这里执行一些初始化操作，只会被执行一次
}
func main() {
    // 在程序启动时执行initOperation函数，保证初始化只被执行一次
    once.Do(initOperation)   
    // 后续代码
}

package main
import (
    "fmt"
    "sync"
)
var (
    config map[string]string
    once   sync.Once
)
func loadConfig() {
    // 模拟从配置文件中加载配置信息
    fmt.Println("load config...")
    config = make(map[string]string)
    config["host"] = "127.0.0.1"
    config["port"] = "8080"
}
func GetConfig() map[string]string {
    once.Do(loadConfig)
    return config
}
func main() {
    // 第一次调用GetConfig会执行loadConfig函数，初始化config变量
    fmt.Println(GetConfig())
    // 第二次调用GetConfig不会执行loadConfig函数，直接返回已初始化的config变量
    fmt.Println(GetConfig())
}

load config...
map[host:127.0.0.1 port:8080]
map[host:127.0.0.1 port:8080]

type Once struct {
   done uint32
   m    Mutex
}
func (o *Once) Do(f func()) {    
    // 判断done标记位是否为0
   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()
   }
}

var config map[string]string
func initConfig() {
    fmt.Println("initConfig called")
    config["1"] = "hello world"
}
func getConfig() map[string]string{
    var once sync.Once
    once.Do(initCount)
    fmt.Println("getConfig called")
}
func main() {
    for i := 0; i < 10; i++ {
        go getConfig()
    }
    time.Sleep(time.Second)
}

package main
import (
"fmt"
"sync"
)
func main() {
   var once sync.Once
   var onceBody func()
   onceBody = func() {
      fmt.Println("Only once")
      once.Do(onceBody) // 再次调用once.Do方法
   }
   // 执行once.Do方法
   once.Do(onceBody)
   fmt.Println("done")
}

import (
   "fmt"
   "net"
   "sync"
)
var (
   initialized bool
   connection  net.Conn
   initOnce    sync.Once
)
func initConnection() {
   connection, _ = net.Dial("tcp", "err_address")
}
func getConnection() net.Conn {
   initOnce.Do(initConnection)
   return connection
}
func main() {
   conn := getConnection()
   fmt.Println(conn)
   conn.Close()
}

import (
   "fmt"
   "net"
   "sync"
)
var (
   connection  net.Conn
   initOnce    sync.Once
)
func initConnection() {
   // 尝试建立连接
   connection, err = net.Dial("tcp", "err_address")
    if err != nil {
       panic("net.Dial error")
    }
}
func getConnection() net.Conn {
   initOnce.Do(initConnection)
   return connection
}

type MyOnce struct {
   done int32
   m    sync.Mutex
}
func (o *MyOnce) Do(f func() error) {
   if atomic.LoadInt32(&o.done) == 0 {
      o.doSlow(f)
   }
}
func (o *MyOnce) doSlow(f func() error) {
   o.m.Lock()
   defer o.m.Unlock()
   if o.done == 0 {
      // 只有在函数调用不返回err时,才会设置done
      if err := f(); err == nil {
         atomic.StoreInt32(&o.done, 1)
      }
   }
}

var (
   hasCall bool
   conn    net.Conn
   m       MyOnce
)
func initConn() (net.Conn, error) {
   fmt.Println("initConn...")
   // 第一次执行,直接返回错误
   if !hasCall {
      return nil, errors.New("init error")
   }
   // 第二次执行,初始化成功,这里默认其成功
   conn, _ = net.Dial("tcp", "baidu.com:80")
   return conn, nil
}
func GetConn() (net.Conn, error) {
   m.Do(func() error {
      var err error
      conn, err = initConn()
      if err != nil {
         return err
      }
      return nil
   })
   // 第一次执行之后,将hasCall设置为true,让其执行初始化逻辑
   hasCall = true
   return conn, nil
}
func main() {
   // 第一次执行初始化逻辑,失败
   GetConn()
   // 第二次执行初始化逻辑,还是会执行,此次执行成功
   GetConn()
   // 第二次执行成功,第三次调用,将不会执行初始化逻辑
   GetConn()
}