Go 并发控制：sync.Once 详解

package main
import (  "fmt"  "sync")
func main() {  var once sync.Once  onceBody := func() {    fmt.Println("Only once")  }  done := make(chan bool)  for i := 0; i < 10; i++ {    go func() {      once.Do(onceBody)      done <- true    }()  }  for i := 0; i < 10; i++ {    <-done  }}

$ go run once/main.go Only once

package main
import (  "fmt"  "sync")
func main() {  var once sync.Once  onceBody := func() {    fmt.Println("Only once")  }  for i := 0; i < 10; i++ {    once.Do(onceBody)  }}

$ go run once/main.go Only once

package main
import (  "fmt"  "sync")
func main() {  var once sync.Once  var i = 10  onceBody := func() {    i *= 2  }  done := make(chan bool)  for i := 0; i < 10; i++ {    go func() {      once.Do(onceBody)      done <- true    }()  }  for i := 0; i < 10; i++ {    <-done  }  fmt.Println("i", i)}

$ go run once/main.goi 20

// Copyright 2009 The Go Authors. All rights reserved.// Use of this source code is governed by a BSD-style// license that can be found in the LICENSE file.
package sync
import (  "sync/atomic")
// 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).//// [the Go memory model]: https://go.dev/ref/memtype 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 atomic.Uint32  m    Mutex}
// 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()) {  // Note: Here is an incorrect implementation of Do:  //  //  if o.done.CompareAndSwap(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 o.done.Store must be delayed until after f returns.
  if o.done.Load() == 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.Load() == 0 {    defer o.done.Store(1)    f()  }}

type Once struct {  // done 指示操作是否已执行。  // 它在结构体中位于首位（即第一个字段），因为它用于 hot path。  // hot path 在每个调用点都进行了内联。  // 将 done 放在首位在某些架构（如 amd64 和 386）上允许生成更紧凑的指令，  // 而在其他架构上减少了指令数量（用于计算偏移量）。  done atomic.Uint32  m    Mutex}

// A Uint32 is an atomic uint32. The zero value is zero.type Uint32 struct {  _ noCopy  v uint32}
// noCopy may be added to structs which must not be copied// after the first use.//// See https://golang.org/issues/8005#issuecomment-190753527// for details.//// Note that it must not be embedded, due to the Lock and Unlock methods.type noCopy struct{}
// Lock is a no-op used by -copylocks checker from `go vet`.func (*noCopy) Lock()   {}func (*noCopy) Unlock() {}

func (o *Once) Do(f func()) {  // 注意：以下是一个错误的 Do 实现：  //  //  if o.done.CompareAndSwap(0, 1) {  //    f()  //  }  //  // Do 保证当它返回时，f 已完成。  // 上述实现不满足该保证：    // 给定有两个同时调用的情况，谁取得了 CompareAndSwap 就会执行 f，    // 而第二个调用会立即返回，而不会等待第一个调用的 f 完成。  // 这就是为什么慢路径需要退回到使用互斥锁 Mutex，  // 并且为什么 o.done.Store 必须延迟到 f 返回之后。    if o.done.Load() == 0 {    // 慢路径（slow-path）分离，以允许对快路径（fast-path）进行内联。    o.doSlow(f)  }}
func (o *Once) doSlow(f func()) {  o.m.Lock()  defer o.m.Unlock()  if o.done.Load() == 0 {    defer o.done.Store(1)    f()  }}

package once
import "sync"
func main() {  var once sync.Once  once.Do(func() {    println("Only once")  })}

$ go build -gcflags='-m' inlining/once/main.go  # command-line-argumentsinlining/once/main.go:7:10: can inline main.func1inlining/once/main.go:7:9: inlining call to sync.(*Once).Doinlining/once/main.go:7:9: inlining call to atomic.(*Uint32).Loadinlining/once/main.go:6:6: moved to heap: onceinlining/once/main.go:7:10: func literal does not escape

package sync
import (  "sync"  "sync/atomic")
type Once struct {  done atomic.Uint32  m    sync.Mutex}
func (o *Once) Do(f func()) {  if o.done.Load() == 0 {    o.m.Lock()    defer o.m.Unlock()    if o.done.Load() == 0 {      defer o.done.Store(1)      f()    }  }}

package once
import "github.com/jianghushinian/blog-go-example/sync/once/inlining/myonce/sync"
func main() {  var once sync.Once  once.Do(func() {    println("Only once")  })}

$ go build -gcflags='-m' inlining/myonce/main.go# command-line-argumentsinlining/myonce/main.go:5:6: can inline maininlining/myonce/main.go:7:10: can inline main.func1inlining/myonce/main.go:6:6: moved to heap: onceinlining/myonce/main.go:7:10: func literal does not escape

// OnceFunc returns a function that invokes f only once. The returned function// may be called concurrently.//// If f panics, the returned function will panic with the same value on every call.func OnceFunc(f func()) func() {  var (    once  Once    valid bool    p     any  )  // Construct the inner closure just once to reduce costs on the fast path.  g := func() {    defer func() {      p = recover()      if !valid {        // Re-panic immediately so on the first call the user gets a        // complete stack trace into f.        panic(p)      }    }()    f()    f = nil      // Do not keep f alive after invoking it.    valid = true // Set only if f does not panic.  }  return func() {    once.Do(g)    if !valid {      panic(p)    }  }}

package main
import (  "fmt"  "sync")
func main() {  onceBody := sync.OnceFunc(func() {    fmt.Println("Only once")  })  done := make(chan bool)  for i := 0; i < 10; i++ {    go func() {      onceBody()      done <- true    }()  }  for i := 0; i < 10; i++ {    <-done  }}

$ go run oncefunc/main.go                       Only once

package main
import (  "fmt"  "sync")
func main() {  onceBody := sync.OnceFunc(func() {    panic("Only once")  })
  for i := 0; i < 5; i++ {    func() {      defer func() {        r := recover()        fmt.Println("recover", r)      }()      onceBody()    }()  }}

$ go run oncefunc/panic/main.gorecover Only oncerecover Only oncerecover Only oncerecover Only oncerecover Only once

package main
import (  "fmt"  "sync")
func main() {  var once sync.Once  onceBody := func() {    panic("Only once")  }
  for i := 0; i < 5; i++ {    func() {      defer func() {        r := recover()        fmt.Println("recover", r)      }()      once.Do(onceBody)    }()  }}

$ go run once/panic/main.gorecover Only oncerecover <nil>recover <nil>recover <nil>recover <nil>

// OnceValue returns a function that invokes f only once and returns the value// returned by f. The returned function may be called concurrently.//// If f panics, the returned function will panic with the same value on every call.func OnceValue[T any](f func() T) func() T {  var (    once   Once    valid  bool    p      any    result T  )  g := func() {    defer func() {      p = recover()      if !valid {        panic(p)      }    }()    result = f()    f = nil    valid = true  }  return func() T {    once.Do(g)    if !valid {      panic(p)    }    return result  }}

package main
import (  "fmt"  "sync")
func main() {  once := sync.OnceValue(func() int {    sum := 0    for i := 0; i < 1000; i++ {      sum += i    }    fmt.Println("Computed once:", sum)    return sum  })  done := make(chan bool)  for i := 0; i < 10; i++ {    go func() {      const want = 499500      got := once()      if got != want {        fmt.Println("want", want, "got", got)      }      done <- true    }()  }  for i := 0; i < 10; i++ {    <-done  }}

$ go run oncevalue/main.go Computed once: 499500

// OnceValues returns a function that invokes f only once and returns the values// returned by f. The returned function may be called concurrently.//// If f panics, the returned function will panic with the same value on every call.func OnceValues[T1, T2 any](f func() (T1, T2)) func() (T1, T2) {  var (    once  Once    valid bool    p     any    r1    T1    r2    T2  )  g := func() {    defer func() {      p = recover()      if !valid {        panic(p)      }    }()    r1, r2 = f()    f = nil    valid = true  }  return func() (T1, T2) {    once.Do(g)    if !valid {      panic(p)    }    return r1, r2  }}

package main
import (  "fmt"  "os"  "sync")
func main() {  once := sync.OnceValues(func() ([]byte, error) {    fmt.Println("Reading file once")    return os.ReadFile("oncevalues/example_test.go")  })  done := make(chan bool)  for i := 0; i < 10; i++ {    go func() {      data, err := once()      if err != nil {        fmt.Println("error:", err)      }      _ = data // Ignore the data for this example      done <- true    }()  }  for i := 0; i < 10; i++ {    <-done  }}

$ go run oncevalues/main.goReading file once