单例模式.md

单例模式

比较简单的一种设计模式，就不单独开一个源码了。

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

1. 懒汉模式（Lazy Loading）

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

type singleton struct {
}

// private
var instance *singleton

// public
func GetInstance() *singleton {
    if instance == nil {
        instance = &singleton{}     // not thread safe
    }
    return instance
}

2. 带锁的单例模式

这里使用了Go的sync.Mutex,其工作模型类似于Linux内核的futex对象，具体实现极其简单，性能也有保证 初始化时填入的0值将mutex设定在未锁定状态，同时保证时间开销最小 这一特性允许将mutex作为其它对象的子对象使用

import "sync"

type singleton struct {
}

var instance *singleton
var mu sync.Mutex

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

    if instance == nil {
        instance = &singleton{}     // unnecessary locking if instance already created
    }
    return instance
}

3. 带检查锁的单例模式

    if instance == nil {     // <-- Not yet perfect. since it's not fully atomic
        mu.Lock()
        defer mu.Unlock()
 
        if instance == nil {
            instance = &singleton{}
        }
    }
    return instance
}

这是一个不错的方法，但是还并不是很完美。因为编译器优化没有检查实例存储状态。如果使用sync/atomic包的话 就可以自动帮我们加载和设置标记。

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
}

repl.go:8:8: not a type: atomic.LoadUInt32 <*ast.SelectorExpr>

4.比较好的一种方式sync.Once

import (
    "sync"
)
 
type singleton struct {
}
 
var instance *singleton
var once sync.Once
 
func GetInstance() *singleton {
    // 使用Once保证创建实例的方法永远只能运行一次
    once.Do(func() {
        instance = &singleton{}
    })
    return instance
}

使用实例

type singleton struct {
}
 
var instance *singleton
var once sync.Once
 
func GetInstance() *singleton {
    // 使用Once保证创建实例的方法永远只能运行一次
    once.Do(func() {
        instance = &singleton{}
    })
    return instance
}

import "fmt"

type ChocolateBoiler struct {
    empty bool
    boiled bool
}
 
var instance *ChocolateBoiler
var once sync.Once
 
func GetInstance() *ChocolateBoiler {
    // 使用Once保证创建实例的方法永远只能运行一次
    once.Do(func() {
        instance = &ChocolateBoiler{true,false}
    })
    return instance
}

func (c *ChocolateBoiler) IsEmpty() bool {
    return c.empty
}

func (c *ChocolateBoiler) IsBoiled() bool {
    return c.boiled
}

func (c *ChocolateBoiler) Fill(){
    if c.empty{
        c.empty = false
        fmt.Println("容器装满了")
    }
}

func (c *ChocolateBoiler) Drain(){
    if c.empty==false && c.boiled {
        c.empty = true
        c.boiled = false
        fmt.Println("倒入模具了")
    }
}

func (c *ChocolateBoiler) Boil(){
    if c.empty==false && c.boiled == false {
        fmt.Println("巧克力煮开了")
        c.boiled = true
    }
}

instance = GetInstance()

instance.IsBoiled()

false

instance.IsEmpty()

true

instance.Fill()

容器装满了

instance.Boil()

巧克力煮开了

instance.Drain()

倒入模具了

instance.IsEmpty()

true

instance.IsBoiled()

false