Go的单例模式

单例模式是一种经常使用的软件设计模式。在它的核心结构中只包含一个被称为单例类的特殊类。经过单例模式能够保证系统中一个类只有一个实例并且该实例易于外界访问，从而方便对实例个数的控制并节约系统资源。若是但愿在系统中某个类的对象只能存在一个，单例模式是最好的解决方案。

1.Go实现非线程安全的单例模式(懒汉 就是很懒的单例 哈哈)：

kage singleton

type singleton struct {
}

var instance *singleton

func GetInstance() *singleton {
	if instance == nil {
		instance = &singleton{}   // <--- NOT THREAD SAFE
	}
	return instance
}

　　

非线程安全的单例模式是你们用得最多的一种。在Github上面的开源项目有不少都使用了非线程安全的。

这种写法lazy loading很明显，可是致命的是在多线程不能正常工做。

2.Go实现带线程锁的单例模式

varmu Sync.Mutex
 
func GetInstance()*singleton{
    mu.Lock()                    // <--- Unnecessary locking if instance already created
    defer mu.Unlock()
 
    ifinstance==nil{
        instance=&singleton{}
    }
    returninstance
}

这里用了Go的sync/mutex

sync/mutext是Go语言底层基础对象之一，用于构建多个goroutine间的同步逻辑，所以被大量高层对象所使用。

其工做模型相似于Linux内核的futex对象，具体实现极为简洁，性能也有保证。

mutex对象仅有两个数值字段，分为为state（存储状态）和sema（用于计算休眠goroutine数量的信号量）。
初始化时填入的0值将mutex设定在未锁定状态，同时保证时间开销最小。
这一特性容许将mutex做为其它对象的子对象使用。

3.带检查锁的的单例模式

func GetInstance()*singleton{
    ifinstance==nil{     // <-- Not yet perfect. since it's not fully atomic
        mu.Lock()
        defer mu.Unlock()
 
        ifinstance==nil{
            instance=&singleton{}
        }
    }
    returninstance
}

　　

这是一个不错的方法，可是还并非很完美。由于编译器优化没有检查实例存储状态。若是使用sync/atomic包的话 就能够自动帮咱们加载和设置标记。

rt "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
}

　　

我的以为比较好的在go中使用单例设计的是这种

packagesingleton
 
import(
    "sync"
)
 
typesingletonstruct{
}
 
varinstance *singleton
varonce sync.Once
 
func GetInstance()*singleton{
    once.Do(func(){
        instance=&singleton{}
    })
    returninstance
}

　　

经过使用sync.Once 包能够实现线程安全的单例模式。

若是写得有什么不对地方欢迎指出。

 

转自：https://xiequan.info/go%E7%9A%84%E5%8D%95%E4%BE%8B%E6%A8%A1%E5%BC%8F/