sync.Once简介

最新推荐文章于 2024-04-30 17:28:01 发布

ZVAyIVqt0UFji

最新推荐文章于 2024-04-30 17:28:01 发布

阅读量753

点赞数 2

文章标签： java 多线程 python 设计模式 linux

本文链接：https://blog.csdn.net/ZVAyIVqt0UFji/article/details/120897412

版权

sync.Once介绍

sync.Once 是 Go 标准库提供的使函数只执行一次的实现，常应用于单例模式，例如初始化配置、保持数据库连接等。作用与 init 函数类似，但有区别。

init 函数是当所在的 package 首次被加载时执行，若迟迟未被使用，则既浪费了内存，又延长了程序加载时间。sync.Once 可以在代码的任意位置初始化和调用，因此可以延迟到使用时再执行，并发场景下是线程安全的。在多数情况下，sync.Once 被用于控制变量的初始化，这个变量的读写满足如下三个条件：

当且仅当第一次访问某个变量时，进行初始化（写）；变量初始化过程中，所有读都被阻塞，直到初始化完成；变量仅初始化一次，初始化完成后驻留在内存里。sync.Once 仅提供了一个方法 Do，参数 f 是对象初始化函数。

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

使用场景

为了更好的说明sync.Once的使用场景，我们先了解一下golang里面单例模式的实现，单例模式的实现一般有以下几种方式

懒汉模式

type DemoModel struct{}
var ins *DemoModel
func InsDemoModel() *DemoModel {
    if ins == nil {
        ins = new(DemoModel)
    }
    return ins
}

缺点：非线程安全，当并发创建时候单例类会有多个实例

饿汉模式

type DemoModel struct{}
var ins *DemoModel = new(DemoModel)
func InsDemoModel() *DemoModel {
    return ins
}

缺点：(1)因为启动时就会实例化，会加长程序启动时间，(2)实例可能未使用，造成内存浪费

懒汉加锁

type DemoModel struct{}
var ins *DemoModel
var mu sync.Mutex
func InsDemoModel() *DemoModel {
    mu.Lock()
    defer mu.Unlock()


    if ins == nil {
        ins = new(DemoModel)
    }
    return ins
}

缺点：解决了并发问题，但每次加锁也是有代价的

双重锁

type DemoModel struct{}
var ins *DemoModel
var mu sync.Mutex
func InsDemoModel() *DemoModel {
    if ins == nil {
        mu.Lock()
        defer mu.Unlock()


        if ins == nil {
            ins = new(DemoModel)
        }
    }
    return ins
}

优点：避免了每次都加锁，提交运行效率

看完了上面几种单例模式的实现，我们应该就知道了sync.Once的使用场景了。

sync.Once 使用示例

还拿单例模式来举例，函数 InsDemoModel 会初始化一个model 并返回相应的实例，初始化方法没有多余的参数，执行过程中不会发生改变。InsDemoModel，为了提升性能（减少执行时间和内存占用），使用 sync.Once 是一个比较好的方式。

type DemoModel struct{


}


var (
    once   sync.Once
    ins *DemoModel
)


func InsDemoModel() *DemoModel {
    once.Do(func() {
        ins = new(DemoModel)
        log.Println("Get DemoModel instance")
    })
    return ins
}


func main() {
    for i := 0; i < 10; i++ {
        go func() {
            _ = InsDemoModel()
        }()
    }
    time.Sleep(time.Second)
}

在这个例子中，声明了 2 个全局变量，once 和 ins；ins 是需要在 InsDemoModel 函数中初始化的，InsDemoModel 可能会被并发调用。如果 InsDemoModel 每次都构造出一个新的 DemoModel 结构体，既浪费内存，又浪费初始化时间。如果 InsDemoModel 中不加锁，初始化全局变量 DemoModel 就可能出现并发冲突。这种情况下，使用 sync.Once 既能够保证全局变量初始化时是线程安全的，又能节省内存和初始化时间。

运行结果如下：

$ go run main.go
2021/06/23 20:27:06 Get DemoModel instance

Get DemoModel instance 仅打印了一次，即 sync.Once 中的初始化函数仅执行了一次。

sync.Once 的原理及实现

保证变量仅被初始化一次，需要有个标志来判断变量是否已初始化过，若没有则需要初始化。线程安全，支持并发，无疑需要互斥锁来实现。

以下是 sync.Once 的源码实现，代码位于 $GOROOT/src/sync/once.go：

package sync


import (
    "sync/atomic"
)


type Once struct {
    done uint32
    m    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()
    }
}

可以看到 sync.Once 的实现与上文中单例模式的第4种实现是类似的，使用 done 标记是否已经初始化，使用锁 m Mutex 实现线程安全。

这里面的done的实现也很有特点，我们来看一下done的注释

type 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/x86),
    // and fewer instructions (to calculate offset) on other architectures.
    done uint32
    m    Mutex
}

其中解释了为什么将 done 置为 Once 的第一个字段：done 在热路径中，done 放在第一个字段，能够减少 CPU 指令，也就是说，这样做能够提升性能。

简单解释一下：

热路径(hot path)是程序非常频繁执行的一系列指令，sync.Once 绝大部分场景都会访问 o.done，在热路径上是比较好理解的，如果 hot path 编译后的机器码指令更少，更直接，必然是能够提升性能的。

为什么放在第一个字段就能够减少指令呢？因为结构体第一个字段的地址和结构体的指针是相同的，如果是第一个字段，直接对结构体的指针解引用即可。如果是其他的字段，除了结构体指针外，还需要计算与第一个值的偏移(calculate offset)。在机器码中，偏移量是随指令传递的附加值，CPU 需要做一次偏移值与指针的加法运算，才能获取要访问的值的地址。因为，访问第一个字段的机器代码更紧凑，速度更快。