Golang设计模式-单例模式

一.介绍

意图：保证一个类仅有一个实例，并提供一个访问它的全局访问点。

主要解决：一个全局使用的类频繁地创建与销毁。

何时使用：当您想控制实例数目，节省系统资源的时候。

如何解决：判断系统是否已经有这个单例，如果有则返回，如果没有则创建。

关键代码：构造函数是私有的。

二.代码

2.1 懒汉模式

type singleton struct{}
var ins *singleton
func GetIns() *singleton{
    if ins == nil {
     　ins = &singleton{}
    }
    return ins
}

缺点：非协程安全。当正在创建时，有协程来访问此时ins = nil就会再创建，单例类就会有多个实例了。

2.2 饿汉模式

type singleton struct{}
var ins *singleton = &singleton{}
func GetIns() *singleton{
     return ins
}

缺点：如果singleton创建初始化比较复杂耗时时，加载时间会延长。

2.3 懒汉加锁

type singleton struct{}
var ins *singleton
var mu sync.Mutex
func GetIns() *singleton{
    mu.Lock()
    defer mu.Unlock()
    if ins == nil {
     　　ins = &singleton{}
    }
    return ins
}

缺点：虽然解决并发的问题，但每次加锁是要付出代价的

2.4 双重锁

type singleton struct{}
var ins *singleton
var mu sync.Mutex
func GetIns() *singleton{  
  　if ins == nil {
     　mu.Lock()
       defer mu.Unlock()
       if ins == nil {
       　ins = &singleton{}
       }
    }
    return ins
}

2.5 sync.Once实现

type singleton struct{}
var ins *singleton
var once sync.Once
func GetIns() *singleton {
    once.Do(func(){
       ins = &singleton{}
    })
    return ins
}

三.优缺点

优点：

• 在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如管理学院首页页面缓存）。
• 避免对资源的多重占用（比如写文件操作）。

缺点：没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。

四.使用场景

• 要求生产唯一序列号。
• WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来。
• 创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等。