导读 这篇文章主要介绍了golang实现单例的操作代码,本文介绍基于sync.Once的方式来实现单例，熟练掌握这种模式，并理解其底层原理，对大部分人来讲已经完全够用了，需要的朋友可以参考下

在go里实现单例模式有多种方式：

  • 基于lock
  • 基于init函数
  • 基于sync.Once

    • 本文介绍基于sync.Once的方式来实现单例，熟练掌握这种模式，并理解其底层原理，对大部分人来讲已经完全够用了。

    基于sync.Once实现单例
    // 其他package也可见，在其他地方也可以new新对象
// 但是最终调用Conn()方法时，都是用的single这个单例
// 1
type Driver struct {
    // 小写字母开头，外部不可访问，所以new个Driver新对象也没用
    // 2
    conn string
}
 
// 全局变量，指针默认值为nil
// 3
var single *Driver // 单例
var once sync.Once
 
// 对外暴露的公共方法
func (s *Driver) Conn() {
    fmt.Printf("conn=%s", single.conn) // do something
}
 
// 4
func GetDriverSingleton() *Driver {
    // 对GetDriverSingleton()方法的调用，都会执行once.Do()方法，只不过参数func()只会被执行一次
    // 若并发执行once.Do()，多个协程会阻塞，因内部是通过Mutex来控制
    once.Do(func() {
        single = new(Driver)
        single.conn = "single conn"
        time.Sleep(50 * time.Millisecond)
    })
    return single
}
    单例类型定义Driver

    Driver类的方法要支持跨包访问，因此需要以大写字母开头。
    小写字母开头，作用域仅限于包内部。

    类Field conn

    类变量conn需要小写字母开头，跨包不可访问，避免在包外被修改。

    但是包内还是有可能被修改。

    once.Do(func() {})

    每次调用GetDriverSingleton()，都会调用once.Do()方法，但是在once.Do()方法内部，仅会执行一次参数func(){}，因此就保证了单例唯一初始化。

    并发访问once.Do()

    不会有并发访问问题，因once.Do()内部通过mutex来控制。

    // once.DO()
if atomic.LoadUint32(&o.done) == 0 {
    // Outlined slow-path to allow inlining of the fast-path.
    o.doSlow(f)
}
 
// doSlow()
func (o *Once) doSlow(f func()) {
    o.m.Lock() // 互斥锁
    defer o.m.Unlock()
    if o.done == 0 {
        defer atomic.StoreUint32(&o.done, 1)
        f()
    }
}
    对外暴露方法Conn()

    外部对Conn()方法的调用，最终都由单例single来实现。

    重新new(Driver)会发生什么？

    很遗憾，无法将构造函数改成private，也就是说，在包外部是可以通过new(Driver)来创建新的对象。

    但无论是哪个对象，对公开方法Conn()的调用，最终都是由单例single来执行的。

    到此这篇关于golang实现单例的操作代码的文章就介绍到这了

    原文来自：https://www.jb51.net/article/266180.htm

    本文地址：https://www.linuxprobe.com/sync-once-linux.html编辑：向云艳，审核员：逄增宝

    Linux命令大全：https://www.linuxcool.com/

    Linux系统大全：https://www.linuxdown.com/

    红帽认证RHCE考试心得：https://www.rhce.net/