大家好,我是晴天,本周我们一起来学习单例模式。本文将介绍单例模式的基本属性,两种构造单例的方法(饿汉模式和懒汉模式)以及golang自带的sync.Once()方法。
GoF对单例模式的定义是:保证一个类、只有一个实例存在,同时提供能对该实例加以访问的全局访问方法。
单例模式属于创建型设计模式,单例模式能够保证一个类全局只有唯一一个实例对象。
在以下几种场景下,建议使用单例模式:
饿汉模式,顾名思义,就是无论是否需要这个单例对象,都在程序运行时,创建这个对象,“饥饿疗法”。我们来看一下常规的一个饿汉模式的写法。
package main
import "fmt"
// 单例模式要点:
/*
1.某个类只能有一个实例
2.该类必须自己创建这个实例
3.该类必须给所有其他对象提供这个实例
综述:保证一个类全局只能有一个实例对象,并提供一个全局访问点
*/
// 1.单例类需要是包内私有的,不能被外界访问到,否则就能实例化多个对象
type singletonCar struct {
name string
}
// 2.访问单例对象的指针必须是私有指针,不能被外界访问到,否则外界就能修改这个指针的指向,导致单例对象丢失
var sc *singletonCar
// 饿汉模式
// 系统启动时就创建单例对象,无论后续是否需要
func init() {
sc = newSingletonCar()
}
func newSingletonCar() *singletonCar {
return &singletonCar{"BMW"}
}
// 3.对外提供的全局访问点,包外能够获得这个单例对象,只提供读权限,不提供写权限
func GetSingleCar() *singletonCar {
return sc
}
// GetSingleCar这个方法只能是普通全局函数,不能是单例类的成员函数
// 以下注释写法是错误的,因为无法获取到单例对象,也就无法调用获取单例对象的函数
//
// func (sc *singletonCar) GetSingleton() *singletonCar {
// return sc
// }
func (sc *singletonCar) PrintCarName() {
fmt.Println(sc.name)
}
func main() {
singleCar := GetSingleCar()
singleCar.PrintCarName() // BMW
singleCar2 := GetSingleCar()
singleCar2.PrintCarName() // BMW
fmt.Println(singleCar == singleCar2) //true
}
上述代码逻辑上看起来没什么问题,能正常运行。但是在实践过程中,发现了一个问题,获取到的这个单例对象,是没有办法作为其他函数的入参或者出参的,因为包外无法拿到这个单例对象的类型。
为了解决上述问题,可以给单例类封装一个接口,让包外以接口的形式访问这个单例。只需要对代码稍作调整即可。
type SingletonCarInterface interface {
PrintCarName()
}
// 3.对外提供的全局访问点,包外能够获得这个单例对象,只提供读权限,不提供写权限
func GetSingleCar() SingletonCarInterface {
return sc
}
懒汉模式,顾名思义就是在第一次获取单例对象的时候,才进行实例化。我们来看一下懒汉模式第一个版本的代码。
package main
import "fmt"
// 1.单例类需要是包内私有的,不能被外界访问到,否则就能实例化多个对象
type singletonCar struct {
name string
}
type SingletonCarInterface interface {
PrintName()
}
// 2.访问单例对象的指针必须是私有指针,不能被外界访问到,否则外界就能修改这个指针的指向,导致单例对象丢失
var s *singletonCar
func newSingletonCar() *singletonCar {
return &singletonCar{
name: "BMW",
}
}
func (sc *singletonCar) PrintName() {
fmt.Println(sc.name)
}
// 懒汉模式在获取对象的时候才会实例化对象
func GetSingleton() SingletonCarInterface {
// 是第一次获取对象
if s == nil {
s = newSingletonCar()
}
return s
}
func main() {
sc := GetSingleton()
sc.PrintName()
}
上述懒汉模式代码如果是在并发场景下的话,就会存在问题,可能会有多个goroutine在同一时刻调用GetSingleton()方法获取单例对象。那么就会创建两个单例对象,其中一个单例对象会被浪费,成为内存垃圾。这就是懒汉模式所存在的并发安全问题
那么既然存在并发安全问题,我们最先想到的解决方法就是加锁,所以就有了第二个版本的懒汉模式的代码(只体现改动部分)
// 新增锁
var lock sync.Mutex
// 懒汉模式在获取对象的时候才会实例化对象
func GetSingleton() SingletonCarInterface {
// 获取对象前,先加锁
lock.Lock()
defer lock.Unlock()
// 不存在对象,则实例化对象
if s == nil {
s = newSingletonCar()
}
return s
}
获取单例对象进行加锁操作,可以保证同一时刻只有一个goroutine获取到互斥锁,从而保证只有第一个进入的goroutine能够创建这个唯一的单例对象,后面的goroutine可以获取到这个唯一的单例对象。
这样写虽然可以解决并发安全的问题,但是由于加锁操作,对性能影响是比较大的,所以这不是一个高效的写法。
针对于加锁性能低下的问题,我们可以使用原子读操作来解决问题,即并不让每一个goroutine都对GetSingleton()方法获取锁,而是首先进行一个原子读操作,只有这个原子值不条件,才允许这个goroutine获取锁。这样可以大大提升性能,我们来看一下代码:
// 新增锁
var lock sync.Mutex
// 原子读操作标记位
var syncNum uint32
// 懒汉模式在获取对象的时候才会实例化对象
func GetSingleton() SingletonCarInterface {
if atomic.LoadUint32(&syncNum) == 1 {
return s
}
// 获取对象前,先加锁
lock.Lock()
defer lock.Unlock()
// 不存在对象,则实例化对象
if s == nil {
s = newSingletonCar()
// 对syncNum这个标记位进行复制操作
atomic.StoreUint32(&syncNum, 1)
}
return s
}
首先进行原子读操作,当标记位是0时,说明没有实例化过这个对象,然后进行加锁操作,实例化单例对象。
tips:
atomic.LoadUint32
是 Go 语言中sync/atomic
包提供的一个函数,用于原子性地加载一个uint32
类型的值。这个函数的目的是在多线程或并发的情况下,确保对该变量的读取操作是原子的,不会被中断或被其他线程的写操作影响,避免竞态条件和数据竞争的问题。
golang自带sync.Once()方法,该方法能够保证内部的函数只执行一次。我们可以使用该方法来创建一个单例对象,代码如下:
package main
import (
"fmt"
"sync"
)
// 1.单例类需要是包内私有的,不能被外界访问到,否则就能实例化多个对象
type singletonCar struct {
name string
}
type SingletonCarInterface interface {
PrintName()
}
// 2.访问单例对象的指针必须是私有指针,不能被外界访问到,否则外界就能修改这个指针的指向,导致单例对象丢失
var s *singletonCar
func newSingletonCar() *singletonCar {
return &singletonCar{
name: "BMW",
}
}
func (sc *singletonCar) PrintName() {
fmt.Println(sc.name)
}
var once sync.Once
// 3.使用sync.Once来保证只实例化一次
func GetSingleton() SingletonCarInterface {
once.Do(func() {
s = newSingletonCar()
})
return s
}
func main() {
sc := GetSingleton()
sc.PrintName()
}
可以看到,once.Do的源码内部也是使用了原子读操作来创建的单例
func (o *Once) Do(f func()) {
// Note: Here is an incorrect implementation of Do:
//
// if atomic.CompareAndSwapUint32(&o.done, 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 atomic.StoreUint32 must be delayed until after f returns.
if atomic.LoadUint32(&o.done) == 0 {
// Outlined slow-path to allow inlining of the fast-path.
o.doSlow(f)
}
}
本文介绍了什么是单例模式(一个类全局只能存在一个实例对象,并且对外只提供一个访问点);用途有哪些场景(访问全局资源;初始化操作很耗时;作为模块或者函数入参非常复杂时);按照对象创建时机不同,分为饿汉模式和懒汉模式两种(饿汉模式:程序启动时创建,懒汉模式:需要用到时创建)以及饿汉模式和懒汉模式的各种使用情况以及有哪些问题。
感谢大家的阅读,晴天将继续努力,分享更多有趣且实用的主题,如有错误和纰漏,欢迎给予指正。 更多文章敬请关注作者个人公众号 晴天码字。 我们下期不见不散,to be continued…