### 概念
保证一个类仅有一个实例，并提供一个访问它的全局访问点。
### 实现
单例实现有两种方式，分别是饿汉模式和懒汉模式，下面分别说明：
#### 1.饿汉模式
```go
type single struct {}
var instance *single
instance = &single{}
func GetSingle() *single {
return instance
}
```
饿汉模式存在问题，instance压根没使用都会自动创建，这时懒汉模式就排上用场了
#### 2.懒汉模式
#### 1）非安全模式
```go
//非安全模式
type single struct {}
var instance *single
func GetSingle() *single {
if instance == nil {
instance = &single{}
}
return instance
}
```
懒汉模式只有通过第一次调用GetSingle时才会创建，但上面GetSingle在多线程环境下是不安全的，如下：
```go
type single struct {}
var instance *single
func GetSingle() *single {
if instance == nil {
fmt.Println("创建实列")
instance = &single{}
}
return instance
}
//通过开启1000个协程，发现会打印出多个"创建实列"
for i := 0; i < 1000; i++{
go GetSingle()
}
```
通过测试，发现会打印出多个"创建实列"，即实列被创建了多次，我们可以通过枷锁的方式，保证GetSingle每次只能被一个协程访问
#### 2）安全模式
```go
type single struct {}
var instance *single
var m sync.Mutex
func GetSingle() *single {
if instance == nil {
m.Lock() //加锁，防止多线程异常
if instance == nil {
instance = &single{}
}
m.Unlock()
}
return instance
}
```
### 3）go专属单例实现
go语言有一个once.Do函数，保证函数只被执行一次，利用这一特性，来实现单例，
once.Do是多协程安全的
```go
type single struct {}
var instance *single
var once sync.Once
func GetSingle() *single {
once.Do(func() {
instance= &single{}
})
return instance
}
```
有疑问加站长微信联系（非本文作者））
