GO单例模式

一、Go语言惯用的单例模式

使用sync包下once对象提供的Do方法,只执行一次

源码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
type Once struct {     
done uint32 //标识是否做完,做完是1
m Mutex //锁
}

//通过原子操作判断o.done,如果o.done==0则f未被执行完,进入doSlow(f func()),如果f执行完则退出Do()。
func (o *Once) Do(f func()) {
if atomic.LoadUint32(&o.done) == 0 {
o.doSlow(f)
}}

//通过加锁的方式,执行`f`,并在`f`执行结束时,将`o.done`置为1
func (o *Once) doSlow(f func()) {
o.m.Lock()
defer o.m.Unlock()
if o.done == 0 {
defer atomic.StoreUint32(&o.done, 1)
f()
}
}

once详细解读:sync.once详解

实现方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package singleton

import (
"sync"
)

type singleton struct {}

var instance *singleton
var once sync.Once

func GetInstance() *singleton {
once.Do(func() {
instance = &singleton{}
})
return instance
}

二、原子类加锁

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
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
}

三、直接上重锁

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
var mu Sync.Mutex

type singleton struct

var instance *singleton

func GetInstance() *singleton {
mu.Lock() // 如果实例存在没有必要加锁
defer mu.Unlock()

if instance == nil {
instance = &singleton{}
}
return instance
}