Golang单例模式

定义：

单例对象的类必须保证只有一个实例存在，全局有唯一接口访问。

分类：

懒汉方式：指全局的单例实例在第一次被使用时构建。
饿汉方式：指全局的单例实例在类装载时构建。

实现：

懒汉方式

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

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

饿汉方式

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

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

懒汉加锁

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
}

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

双重锁

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
}

避免了每次加锁，提高代码效率
这次我们用了两个判断，而且我们将同步锁放在了条件判断之后，这样做就避免了每次调用都加锁，提高了代码的执行效率。理论上写到这里已经是很完美的单例模式了，但是我们在go语言里，我们有一个很优雅的写法。

sync.Once实现

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

Once.Do方法的参数是一个函数，这里我们给的是一个匿名函数，在这个函数中我们做的工作很简单，就是去赋值m变量，而且go能保证这个函数中的代码仅仅执行一次！

原文链接：golang单例模式