前言

虽说Golang并不是C++、Java这种传统的面向对象语言，而是偏向于面向接口编程的语言。但是Golang依旧有接口、结构体、组合等概念去模拟所谓面向对象中非常重要的设计模式。基于面向对象的模型去编写代码往往能编写成高内聚、低耦合、扩展性极强、难出bug的高质量代码结构。

而这个系列主要介绍比较常用的创造型、结构型、行为型设计模式以及Golang中的实现、案例.......

什么是单例模式？

单例模式是一类经典且简单的设计模式

在单例模式下，我们的目的是声明一个类并保证这个类只存在全局唯一的实例供外部反复使用.

而要点简要来讲就是：

1.该类在整个运行周期中仅能够被实例化一次
2.该类的实例化对象对外是不可见的，且必须自行提供一个公共的访问点供客户端去使用
3.该实例应被自行创建

那么符合以上标准那便是一个单例模式的使用

那么其实说到这里大家肯定就会想到在日常工程中，很多组件的实例其实就是用了单例模式来初始化的。比如Mysql中间件，我们就希望该DB类仅被初始化一次，并暴露一个全局的DB供应。又或者系统要求提供一个唯一的序列号生成器或资源管理器，或者需要考虑资源消耗太大而只允许创建一个对象。

饿汉模式与懒汉模式

而单例模式的实现又分为了两种，分别是饿汉模式与懒汉模式。

饿汉模式

顾名思义，饿汉就是说很饿，很饿怎么办？程序一运行，那么就将这个单例去初始化拿到实例不就不饿了么=0= ~

饿汉模式的Golang实现代码Demo

再回顾一下单例模式的标准

1.该类在整个运行周期中仅能够被实例化一次
2.该类的实例化对象对外是不可见的，且必须自行提供一个公共的访问点供客户端去使用
3.该实例应被自行创建

简单看一下饿汉式

//1、保证这个类非公有化，外界不能通过这个类直接创建一个对象
//   那么这个类就应该变得非公有访问 类名称首字母要小写
type singelton struct {
   }

//2、但是还要有一个指针可以指向这个唯一对象，但是这个指针永远不能改变方向
//   Golang中没有常指针概念，所以只能通过将这个指针私有化不让外部模块访问
var instance *singelton = new(singelton)

//3、如果全部为私有化，那么外部模块将永远无法访问到这个类和对象，
//   所以需要对外提供一个方法来获取这个唯一实例对象
//   注意：这个方法是否可以定义为singelton的一个成员方法呢？
//       答案是不能，因为如果为成员方法就必须要先访问对象、再访问函数
//        但是类和对象目前都已经私有化，外界无法访问，所以这个方法一定是一个全局普通函数
func GetInstance() *singelton {
   
    return instance
}

func (s *singelton) SomeThing() {
   
    fmt.Println("单例对象的某方法")
}

func main() {
   
    s := GetInstance()
    s.SomeThing()
}

这就是饿汉式一个简单的demo，在程序进入main()前instance就已经被实例化了

懒汉模式

而与之对应的就是懒汉模式了。唯一不同之处就是懒汉模式并不会在一开始就去实例化该单例，而是在第一次使用到它的时候，才会将其初始化并返回。。这就引伸出了一个问题，我们如何让这个单例只在第一次被调用的时候而初始化？换言之怎么让该实例被初始化的业务代码只能被全局调用一次？

而这个问题对熟悉Golang的小伙伴并不是什么难事，因为Golang其实有提供sync.once这样一个接口来让某个逻辑只在这个程序中执行一次。

package main

import (
    "fmt"
    "sync"
)

var once sync.Once

type singelton struct {
   }

var instance *singelton

func GetInstance() *singelton {
   

    once.Do(func(){
   
        instance = new(singelton)
    })

    return instance
}

func (s *singelton) DoPrint() {
   
    fmt.Println("666")
}

func main() {
   
    s := GetInstance()
    s.SomeThing()
}

当我们使用现成封装好的api时，我们应该有刨根问底的心态，知其然知其所以然。下面我们简单看看sync.once的底层代码是怎样的。

type Once struct {
    // 通过一个整型变量标识，once 保护的函数是否已经被执行过
    done uint32
    // 一把锁，在并发场景下保护临界资源 done 字段只能串行访问
    m    Mutex
}

在 sync.Once 的定义类中 包含了两个核心字段：

• done：一个整型 uint32，用于标识用户传入的任务函数是否已经执行过了
• m：一把互斥锁 sync.Mutex，用于保护标识值 done ，避免因并发问题导致数据不一致(保证线程安全)

func (o *Once) Do(f func()) {
    // 锁外的第一次 check，读取 Once.done 的值
    if atomic.LoadUint32(&o.done) == 0 {
        o.doSlow(f)
    }
}

func (o *Once) doSlow(f func()) {
    // 加锁
    o.m.Lock()
    defer o.m.Unlock()
    // double check
    if o.done == 0 {
        // 任务执行完成后，将 Once.done 标识为 1
        defer atomic.StoreUint32(&o.done, 1)
        // 保证全局唯一一次执行用户注入的任务
        f()
    }
}

而Do就是让里面的代码能被只执行一次的核心代码块，代码很清晰易懂，我就不过多赘述，主要通过atomic进行原子性的对done这个状态量去变更，以及核查值是否变更过来判断该f函数是否被执行过。

总结

以上就是我对单例模式的讲解以及Go实现，顺便讲解了一下sync.once底层原理