乐趣区

关于golang:GolangsyncOnce用法以及源码讲解

前言

在咱们开发过程中常常会应用到单例模式这一经典的设计模式,单例模式能够帮忙开发者针对某个(些)变量或者对象或者函数(办法)进行在程序运行期间只有一次的初始化或者函数调用操作,比方在开发我的项目中针对某一类连接池的初始化(如数据库连接池等)。针对这种状况,咱们就须要应用单例模式进行操作。

单例模式🌰

本人搞得单例模式

要实现一个单例模式,咱们会很快就想到了在一个构造体中搁置一个 flag 字段用于标记以后的函数是否被执行过,举个🌰:

`type SingletonPattern struct {`
 `done bool`
`}`
`func (receiver *SingletonPattern) Do(f func())  {`
 `if !receiver.done {`
 `f()`
 `receiver.done=true`
 `}`
`}`

看似很美妙,然而此时,如果传入的须要调用的函数 f() 会执行很长时间,比方数据库查问或者做一些连贯什么的,当别的 goroutine 运行到此处的时候因为还没有执行完 f(),就会发现done 标记依然是false,那么依然会调用一次f(),此时就违反了单例模式的初衷。

那么如何解决下面的并发的问题呢。此时就能够应用 go 规范库中所提供的并发原语 —sync.Once

规范库真香系列之sync.Once

话不多说先上sync.Once 构造体的源代码:

`type Once struct {`
 `// 标记符号,用于标记是否执行过 `
 `done uint32`
 `// 互斥锁,用于爱护并发调用以及避免 copy`
 `m    Mutex`
`}`

构造体就这么简略,字段 done 用于标记是否执行过函数,至于为什么应用 uint32 类型,作者的了解是为了之后应用 atomic 操作做的斗争,m字段值用于爱护并发状况下的情景,并且因为继承了 Locker 接口能够通过 vet 校验到其是否被复制

接下来看一下用于执行函数调用的 Do() 函数的实现:

`func (o *Once) Do(f func()) {`
 `// 原子获取以后 done 字段是否等于 0`
 `// 如果以后字段等于 1` 
 `// 则代表曾经 执行过 `
 `// 这是第一层校验 `
 `if atomic.LoadUint32(&o.done) == 0 {`
 `// 如果为 0 则代表没被调用过则调用 `
 `// 此处写成一个函数的起因是为了 `
 `// 进行函数内联晋升性能 `
 `o.doSlow(f)`
 `}`
`}`
`func (o *Once) doSlow(f func()) {`
 `// 此处加锁用于避免其余 goroutine 同时拜访调用 `
 `o.m.Lock()`
 `defer o.m.Unlock()`
 `// 二次校验 `
 `// 为的是避免多个 goroutine 进入此函数的时候,可能产生的反复执行 f()`
 `if o.done == 0 {`
 `// 函数执行完结设置 done 字段为 1 代表曾经执行结束 `
 `defer atomic.StoreUint32(&o.done, 1)`
 `// 执行 `
 `f()`
 `}`
`}`

此时,sync.Once 的所有源代码曾经解析结束了(惊不惊喜,意不意外),其实sync.Once 的过程很简略,就是依据标记进行双重判断确定函数是否执行过,没执行就执行,执行了就跳过。

sync.Once 的应用问题

哪来的 deadlock?

sync.Once 确实很简略,应用也很简略,然而还是会有应用上可能呈现的一些问题比方下列代码:

`func main() {`
 `var once sync.Once`
 `once.Do(`
 `func() {`
 `fmt.Println("one once do")`
 `once.Do(`
 `func() {`
 `fmt.Println("second once do")`
 `})`
 `})`
`}`

该代码会呈现什么问题?答案是:

fatal error: all goroutines are asleep – deadlock!

为什么会这样?因为内层个 Do 是被外层的同一个 once 对象所调用,因为此时曾经进入了第一个 Do 并且曾经调用了函数,那么此时sync.Once 中的互斥锁字段,曾经被加了锁,此时二次加锁就会产生死锁。因而应用sync.Once 最重要的一点就是:*

不要在执行函数中,嵌套以后的sync.Once 对象 不要在执行函数中,嵌套以后的sync.Once 对象 不要在执行函数中,嵌套以后的sync.Once 对象。(重要的话要说三遍)

哪来的 invalid memory address or nil pointer dereference?

看一下上面的代码:

`func main() {`
 `var once sync.Once`
 `var conn net.Conn`
 `once.Do(`
 `func() {`
 `var err error`
 `conn, err = net.Dial("tcp", "")`
 `if err != nil {`
 `return`
 `}`
 `})`
 `conn.RemoteAddr()`
`}`

在运行时,会呈现:

panic: runtime error: invalid memory address or nil pointer dereference

为什么?因为 sync.Once 只保障执行一次,然而不保障执行是否出错 ,即 我只管调用,出错了跟我无关,上述代码中

`conn, err = net.Dial("tcp", "")`

必然呈现 err!=nil 的状况,此时如果不对 conn 变量进行判断为nil,就会呈现空指针异样,那么,如何来保障他执行胜利了呢,咱们须要对其进行革新

`type Once struct {`
 `once sync.Once`
`}`
`func (receiver *Once) OnceDo(f func() error) error {`
 `var err error`
 `receiver.once.Do(`
 `func() {`
 `err = f()`
 `})`
 `return err`
`}`
`func main() {`
 `var once Once`
 `var conn net.Conn`
 `err := once.OnceDo(`
 `func() error {`
 `var err error`
 `conn, err = net.Dial("tcp", "")`
 `if err != nil {`
 `return err`
 `}`
 `return nil`
 `})`
 `if err != nil {`
 `log.Fatal(err)`
 `}`
`}`

通过封装,咱们就能够失去sync.Once 执行时是否出错,以适配各种错误处理。

此封装可能会有更好的解决方案,下面的计划也仅仅是一个🌰罢了。

总结

至此sync.Once 的用法以及源码解析就实现了,可能有些中央有些了解上的谬误,请各位体谅并且帮忙指出修改意见,如果这篇文章能帮到你,这是我的荣幸。

退出移动版