并发编程Once 基本用法和如何实现以及常见错误

Posted 了 凡

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了并发编程Once 基本用法和如何实现以及常见错误相关的知识,希望对你有一定的参考价值。

博主介绍:

我是了 凡 微信公众号【了凡银河系】期待你的关注。未来大家一起加油啊~


前言


Once是什么能做什么?

Once可以用来执行且仅仅执行一次动作,常常用于单例对象的初始化场景。

初始化单例资源有很多方法,比如定义package级别的变量,这样程序在启动的时候就可以初始化:

package abc

import time

var startTime = time.Now()

或者在init函数中进行初始化:

package abc

var startTime time.Time

func init(){
    startTtime = time.Now()
}

又或者在main函数开始执行的时候,执行一个初始化的函数:

package abc

var startTime = time.Now()

func initApp() {
    startTtime = time.Now()
}
func main() {
    initApp()
}

这三种方法都是线程安全的,并且后两种方法还可以根据传入的参数实现定制化的初始化操作。(可是这个和Once有什么关系呢,别着急,记住Once可以用来执行且仅仅执行一次动作

但是很多时候我们是要延迟初始化的,所以有时候单列资源的初始化,我们会使用下面的方法:

// 使用互斥锁保证线程(goroutine)安全
var connMu sync.Mutex
var conn net.Conn

func getConn() net.Conn {
   connMu.Lock()
   defer connMu.Unlock()

   // 返回已创建好的连接
   if conn != nil {
      return conn
   }

   // 创建连接
   conn, _ = net.DialTimeout("tcp","baidu.com:80", 10*time.Second)
   return conn
}

func main() {
   conn := getConn()
   if conn == nil {
      panic("conn is nil")
   }
}

这种方式虽然实现起来简单,但是有性能问题。一旦连接创建好,每次请求的时候还是得竞争锁才能读取到这个连接,这是比较浪费资源的,因为连接如果创建好之后,其实不需要锁的保护了。所以Once并发原语就体现出它的价值了。


Once基础用法以及使用场景

sync.Once只暴露了一个方法Do,你可以多次调用Do方法,但是只有第一次调用Do方法时f参数才会执行,这里的f是一个无参数无返回值的函数。

func (0 *Once) Do(f func())

因为当且仅当第一次调用Do方法的时候参数f才会执行,即使第二次、第三次、第n次调用时f参数的值不一样,也不会被执行,比如下面的例子,虽然f1和f2是不同的函数,但是第二个函数f2就不会执行。

func main() {
   var once sync.Once

   // 第一个初始化函数
   f1 := func() {
      fmt.Println("in f1")
   }
   once.Do(f1) // 打印出 in f1

   // 第二个初始化函数
   f2 := func() {
      fmt.Println("in f2")
   }
   once.Do(f2) // 无输出
}

因为这里的f参数是一个无参数无返回的函数,所以你可能会通过闭包的方式引用的参数,比如:

var adr = "baidu.com"

var conn net.Conn
var err error

once.Do(func() {
    conn, err = net.Dial("tcp", addr)
})

而且在实际的使用中,绝大多数情况下,你会使用闭包的方式去初始化外部的一个资源。

Once的使用场景很明确,在标准库内部实现中也常常看到Once的身影

例如标准库内部 cache的实现上,就使用了Once初始化Cache资源,包括defaultDir值的获取:

func Default() *cache.Cache { // 获取默认的Cache
   defaultOnce.Do(initDefaultCache) // 初始化cache
   return defaultCache
}

// 定义一个全局的cache变量,使用Once初始化,所以也定义了一个Once变量
var (
   defaultOnce  sync.Once
   defaultCache *cache.Cache
)

func initDefaultCache()  { // 初始化cache,也就是Once.Do使用的f函数
   .......
   defaultCache = c
}

// 其他一些Once初始化变量,比如defaultDir
var (
   defaultDirOnce  sync.Once
   defaultDir        string
   defaultDirErr   error
)

还有一些测试的时候初始化测试的资源(export_windows_test):

// 测试window系统调用时区相关函数
func ForceAusFromTZIForTesting() {
    ResetLocalOnceForTest()
        // 使用Once执行一次初始化
    localOnce.Do(func() { initLocalFromTZI(&aus) })
}

除此之外,还要保证只调用一次copyenv的envOnce,strings包下的Replacer,time包中的测试,Go拉取库时的proxy,net.pipe,crc64,Regexp,…,数不胜数。了解一个math/big/sqrt.go中实现的一个数据结构,它通过Once封装了一个只初始化一次的值:

// 值是3.0或者0.0的一个数据结构
var threeOnce struct {
    sync.Once
    v *Float
}

// 返回此数据结构的值,如果还没有初始化为3.0, 则初始化
func three() *Float {
    threeOnce.Do(func() { // 使用Once初始化
        threeOnce.v = NewFloat(3.0)
    }
}

将sync.Once和*Float封装成一个对象,提供了只初始化一次的值v。看它的three方法的实现,虽然每次都调用threeOnce.Do方法,但是参数只会调用一次。

总结

Once并发原语解决的问题和使用场景:Once常常用来初始化单例资源,或者并发访问只需初始化一次的共享资源,或者在测试的时候初始化一次测试资源。


Once如何实现

通过上述的问题你大概应该明白Once是什么以及怎么用了,但是实现的话,也许会像我们想的很简单,比如只需使用一个flag标记是否初始化过即可,最多是用atomic原子操作这个flag,比如下面的实现:

type Once struct {
    done uint32
}

func (o *Once) Do(f func()) {
    if !atomic.CompareAndSwapUint32(&o.done, 0, 1) {
        return
    }
    f()
}

这样是一种实现方式,但是,这个实现有一个很大的问题,就是如果参数f执行很慢的话,后续调用Do方法的goroutine虽然看到done已经设置为执行过了,但是获取某些初始化资源的时候可能会得到空的资源,因为f还没有执行完。

所以,一个正确的Once实现要使用一个互斥锁,这样初始化的时候如果有并发的goroutine,就会进入doSlow方法。互斥锁的机制保证只有一个goroutine进行初始化,同时利用双检查的机制(double-checking),再次判断o.done是否为0,如果为0,则是第一次执行,执行完毕后,就将o.done设置为1,然后释放锁。

即使此时有多个goroutine同时进入了doSlow方法,因为双检查的机制,后续的goroutine会看到o.done的值为1,也不会再次执行f。

这样的话既保证了并发的goroutine会等待f完成,而且还不会多次执行f。

type Once struct {
   done uint32
   m  sync.Mutex
}

func (o *Once) Do(f func())  {
   if atomic.LoadUint32(&o.done) == 0 {
      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()
   }
}

这样呢,基本上我认为了解基本可以了,尽管有些地方还不是很懂,但是对于Once已经可以称为了解了。


使用Once的错误

第一种:死锁

Do方法会执行一次f,但是如果f中再次调用这个Once的Do方法的话,就会导致死锁的情况出现。这还不是无限递归的情况,而是Lock的递归调用导致的死锁。

func main() {
    var once sync.once
    once.Do(func() {
        once.Do(func() {
            fmt.Println("初始化")
        })
    })
}

想要避免这种情况的出现,就不要在f参数中调用当前的这个Once,不管是直接的还是间接的。

第二种: 未初始化

如果f方法执行的时候panic,或者f执行初始化资源的时候失败了,这个时候,Once还是会认为已经成功了,即使再次调用方法,也不会再次执行f。

比如:由于一些防火墙的原语,googleConn并没有被正确的初始化,后面如果想当然认为既然执行了Do方法googleConn就已经初始化的话,会抛出空指针的错误:

func main() {
    var once sync.Once 
    var googleConn net.Conn // 到Google网站的一个连接
    
    once.Do(func() {
            // 建立到google.com的连接,有可能因为网络的原语,googleConn并没有建立成功,此时它的值为nil
             googleConn,_ = net.Dial("tcp","google.com:80")
    })
    // 发送http请求
    googleConn.Write([]byte("GET / HTTP/1.1\\r\\nHost: google.com/r/n Accept: */*\\r\\n\\r\\n"))
    io.Copy(os.Stdout.GoogleConn)
}

执行过Once.Do方法也可能因为函数执行失败的原因未初始化资源,并且以后也没有机会再次初始化资源,那么这种初始化未完成的问题该怎么解决呢?

解法:可以自己实现一个类似Once的并发原语,既可以返回当前调用Do方法是否正确完成,还可以在初始化失败后调用Do方法再次尝试初始化,直到初始化成功才不再初始化了。

// 一个功能更加强大的Once
type Once struct {
    m sync.Mutex
    done uint32
}

// 传入的函数f有返回值error,如果初始化失败,需要返回失败的error
// Do方法会把这个error返回给调用者
func (o *Once) Do(f fucn() error) error {
    if atomic.LoadUint32(&o.done) == 1 { // fast path
        return nil
    }
    return o.slowDo(f)
}
// 如果还没有初始化
func (o *Once) slowDo(f func() error) error {
    o.m.Lock()
    defer o.m.Unlock()
    var err error
    if o.done == 0 { // 双检查,还没有初始化
        err = f()
        if err == nil { // 初始化成功才将标记置为已初始化
            atomic.StoreUint32(&o.done, 1)
        }
    }
    return err
}

改变的地方就是Do方法和参数f函数都会返回error,如果f执行失败,会把这个错误信息返回。

对slowDo方法也做了调整,如果f调用失败,不会更改done字段的值,这样后续degoroutine还会继续调用f。如果f执行成功,才会修改done的值为1。

这个时候有了一个新的问题怎么查询是否初始化过呢?

type AnimalStore struct {
    once sync.Once; inited uint32
}
func (a *AnimalStore) Init() // 可以被并发调用
    a.once.Do(func() {
        longOperationSetupdbOpenFilesQueuesEtc()
        atomic.StoreUint32(&a.inited, 1)
    })
}
func (a *AnimalStore) CountOfCats() (int, error) { // 另外一个goroutine
    if atomic.LoadUint32(&a.inited) == 0 {
        return 0, NotYetInitedError
    }
    // Real operation
}

这样就解决掉了以上的问题

总结

Once常常用来实现单例模式

单例是23种设计模式之一,也是常常引起争议的设计模式之一,甚至有人把它归为反模式。为什么是反模式?(例如标准库钟的单例模式)

因为Go没有immutable类型,导致我们声明的全局变量都是可变的,别的地方或者第三方库可以随意更改这些变量。比如package io 中定义了几个全局变量,比如 io.EOF:

var EOF = errors.NEW("EOF")

因为它是一个package级别的变量,我们可以在程序中把它改了,这会导致一些依赖 io.EOF 这个变量做判断的代码出错。

io.EOF = errors.New("我们自己定义的EOF")
  • 一些单例(全局变量)的确很方便,比如Buffer池或者连接池,所以有时候我们也不要谈虎色变。虽然有人把单例模式称之为反模式,但毕竟只能代表一部分开发者的观点,否则越不会在23种设计模式中了。

  • 如果真的担心这个package级别的变量被人修改,可以不把它们暴露出来,而是提供一个只读的GetXXX的方法,这样别人就不会进行修改了。

  • 而且,Once不只应用于单例模式,一些变量在也需要在使用的时候做延迟初始化,所以也是可以使用Once处理这些场景的。

  • 所以,Once的应用场景很广泛。一旦遇到只需要初始化一次的场景,首先想到的就应该是Once并发原语


这次就先讲到这里,如果想要了解更多的golang语言内容一键三连后序每周持续更新!

以上是关于并发编程Once 基本用法和如何实现以及常见错误的主要内容,如果未能解决你的问题,请参考以下文章

并发编程Cond 基本用法和如何实现以及常见错误

并发编程map 基本用法和常见错误以及如何实现线程安全的map类型

Golang 基础:底层并发原语 Mutex RWMutex Cond WaitGroup Once等使用和基本实现

Golang 基础:底层并发原语 Mutex RWMutex Cond WaitGroup Once等使用和基本实现

Golang 基础:底层并发原语 Mutex RWMutex Cond WaitGroup Once等使用和基本实现

Golang 基础:底层并发原语 Mutex RWMutex Cond WaitGroup Once等使用和基本实现