转载至 https://www.yuque.com/docs/share/17c247e8-961d-4cb1-a647-8ccfb66f4bd4

简介

---

单例模式，是一种常用的软件设计模式，在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以包在系统中一个类只有一个实例且该实例易于访问，从而方便对实例个数的控制并节约系统资源。

懒汉模式(Lazy Loading)

---

懒汉模式是开源项目中使用最多的一种，最大的缺点是非线程安全的。

type singleton struct {
}

// 私有属性
var instance *singleton

// 公开方法
func GetInstance() *singleton {
    if instance == nil {
        instance = &singleton{}     // 没有线程安全
    }
    return instance
}

带锁的单例模式

---

type singleton struct {
}

var instance *singleton
var mu sync.Mutex

func GetInstance() *singleton {
    mu.Lock()
    defer mu.Unlock()

    if instance == nil {
        instance = &singleton{}     // 如果实例已创建，则不必要的锁定
    }
    return instance
}

带检查锁的单例模式

---

if instance == nil {     // 还不够完美。因为它不是完全原子的
        mu.Lock()
        defer mu.Unlock()

        if instance == nil {
            instance = &singleton{}
        }
    }
    return instance
}

import "sync"
import "sync/atomic"

var initialized uint32
...

func GetInstance() *singleton {

    if atomic.LoadUInt32(&initialized) == 1 {
        return instance
    }

    mu.Lock()
    defer mu.Unlock()

    if initialized == 0 {
         instance = &singleton{}
         atomic.StoreUint32(&initialized, 1)
    }

    return instance
}

比较好的一种方式 sync.Once

---

import (
    "sync"
)

type singleton struct {
}

var instance *singleton
var once sync.Once

func GetInstance() *singleton {
    once.Do(func() {
        instance = &singleton{}
    })
    return instance
}