一文搞懂设计模式之单例模式

大家好，我是晴天，本周我们一起来学习单例模式。本文将介绍单例模式的基本属性，两种构造单例的方法（饿汉模式和懒汉模式）以及golang自带的sync.Once()方法。

一文搞懂设计模式之单例模式.png

什么是单例模式

GoF对单例模式的定义是：保证一个类、只有一个实例存在，同时提供能对该实例加以访问的全局访问方法。

单例模式属于创建型设计模式，单例模式能够保证一个类全局只有唯一一个实例对象。

单例模式类图.png

为什么需要单例模式

在以下几种场景下，建议使用单例模式：

某些全局资源进行共享时，需要使用唯一的对象进行访问
某些实例化很费时的操作，只进行一次实例化
某些入参特别复杂的模块或者函数，只用一个实例化对象操作

单例模式的分类

饿汉模式：特点是在类加载的时候就创建实例，而不是在实际使用时再进行实例化
懒汉模式：特点是在实际使用的时候才进行实例化，创建实例

饿汉模式

单例创建步骤.drawio.png

饿汉模式，顾名思义，就是无论是否需要这个单例对象，都在程序运行时，创建这个对象，“饥饿疗法”。我们来看一下常规的一个饿汉模式的写法。

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
}

代码解析：

第一步声明一个单例类singletonCar
第二步声明一个指向单例对象的指针，并初始化单例对象
第三步对外提供一个全局访问函数GetSingleton来获取这个单例对象

问题讨论：

上述代码逻辑上看起来没什么问题，能正常运行。但是在实践过程中，发现了一个问题，获取到的这个单例对象，是没有办法作为其他函数的入参或者出参的，因为包外无法拿到这个单例对象的类型。

改进：

为了解决上述问题，可以给单例类封装一个接口，让包外以接口的形式访问这个单例。只需要对代码稍作调整即可。

type SingletonCarInterface interface {
    PrintCarName()
}

// 3.对外提供的全局访问点，包外能够获得这个单例对象，只提供读权限，不提供写权限
func GetSingleCar() SingletonCarInterface {
    return sc
}

懒汉模式

懒汉模式.drawio.png

懒汉模式，顾名思义就是在第一次获取单例对象的时候，才进行实例化。我们来看一下懒汉模式第一个版本的代码。

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()
}

代码解析：

第一步声明一个单例类singletonCar
第二步声明一个指向单例对象的指针，但是不进行实例化
第三步对外提供一个全局访问函数GetSingleton来获取这个单例对象
第四步判断这个单例是否已经实例化，未实例化则进行实例化操作

代码问题：

上述懒汉模式代码如果是在并发场景下的话，就会存在问题，可能会有多个goroutine在同一时刻调用GetSingleton()方法获取单例对象。那么就会创建两个单例对象，其中一个单例对象会被浪费，成为内存垃圾。这就是懒汉模式所存在的并发安全问题

改进一：

懒汉模式v2.drawio.png

那么既然存在并发安全问题，我们最先想到的解决方法就是加锁，所以就有了第二个版本的懒汉模式的代码（只体现改动部分）

// 新增锁
var lock sync.Mutex

// 懒汉模式在获取对象的时候才会实例化对象
func GetSingleton() SingletonCarInterface {
    // 获取对象前，先加锁
    lock.Lock()
    defer lock.Unlock()
    // 不存在对象，则实例化对象
    if s == nil {
       s = newSingletonCar()
    }
    return s
}

代码解释：

获取单例对象进行加锁操作，可以保证同一时刻只有一个goroutine获取到互斥锁，从而保证只有第一个进入的goroutine能够创建这个唯一的单例对象，后面的goroutine可以获取到这个唯一的单例对象。

代码问题：

这样写虽然可以解决并发安全的问题，但是由于加锁操作，对性能影响是比较大的，所以这不是一个高效的写法。

改进二：

懒汉模式v3.drawio.png

针对于加锁性能低下的问题，我们可以使用原子读操作来解决问题，即并不让每一个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内置方法

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)
    }
}

总结：

本文介绍了什么是单例模式（一个类全局只能存在一个实例对象，并且对外只提供一个访问点）；用途有哪些场景（访问全局资源；初始化操作很耗时；作为模块或者函数入参非常复杂时）；按照对象创建时机不同，分为饿汉模式和懒汉模式两种（饿汉模式：程序启动时创建，懒汉模式：需要用到时创建）以及饿汉模式和懒汉模式的各种使用情况以及有哪些问题。