golang单例模式的实现

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

2 分类:

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

3 实现：

（1）懒汉方式

type Singleton struct {

}
var ins *Singleton

func GetInstance() *Singleton {
	if ins == nil{
		ins =&Singleton{}
	}
	return ins
}

缺点：非线程安全。当正在创建的时候，如果有线程访问此时的ins=nil就会在创建，单例就会实现多个实例了

（2）饿汉方式

type Singleton struct {

}

var ins *Singleton = &Singleton{}
func GetInstance() *Singleton {
	return ins
}

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

（3）懒汉加锁

type Singleton struct {
	num int
}

var ins  *Singleton
var mu sync.Mutex

func GetInstance() *Singleton {
	mu.Lock()
	defer mu.Unlock()
	if ins == nil{
		ins = &Singleton{}
	}
	return ins
}

缺点：虽然解决并发的问题，但每次加锁是需要付出代价的
(4)双重锁（改变加锁位置）

type Singleton struct {
	num int
}

var ins  *Singleton
var mu sync.Mutex

func GetInstance() *Singleton {
	if ins == nil{
		mu.Lock()
		defer mu.Unlock()
		ins = &Singleton{}
	}
	return ins
}

注：避免了每次加锁，提高代码效率

（5）sync.Once实现

type Singleton struct {
	num int
}

var ins  *Singleton
var once sync.Once

func GetInstance() *Singleton {
	once.Do(func() {
		ins = &Singleton{}
	})
	return ins
}

4 sync.Once说明

sync.Once官方描述Once is an object that will perform exactly one action.（Once是一个对象，保证某个动作只被执行一次，最典型的就是单例模式了）

package main

import (
	"fmt"
	"sync"
)

func main() {
	var once sync.Once
	onceBody := func() {
		fmt.Println("Only once")
	}
	done := make(chan bool)
	for i := 0; i < 10; i++ {
		go func() {
			once.Do(onceBody)
			done <- true
		}()
	}
	for i := 0; i < 10; i++ {
		<-done
	}
}

输出内容

Only once

Program exited.

5 源码(once.go)

package sync

import (
	"sync/atomic"
)

type Once struct {

	done uint32
	m    Mutex
}

func (o *Once) Do(f func()) {

// 如果直接 o.done == 0，会导致无法及时观察 doSlow 对 o.done 的值设置。具体原因可以参考 Go 的内存模型
// 当一个变量被多个 gorouting 访问的时候，必须要保证他们是有序的（同步），可以使用 sync 或者 
// sync/atomic 包来实现。用了 LoadUint32 可以保证 doSlow 设置 o.done 后可以及时的被取到。
	if atomic.LoadUint32(&o.done) == 0 {
		o.doSlow(f)
	}
}

func (o *Once) doSlow(f func()) {
	o.m.Lock()
	defer o.m.Unlock()
	// 可以直接使用 o.done == 0 是因为使用了 Mutex 进行了锁操作，o.done == 0 处于锁操作的临界区中，所以可以直接进行比较。
	// Mutex 只能保证临界区内的操作是可观测的 即只有处于o.m.Lock() 和 defer o.m.Unlock()之间的代码对 o.done 的值是可观测的。
	// 那这是 Do 中对 o.done 访问就可以会出现观测不到的情况，因此需要使用 StoreUint32 保证原子性。
	if o.done == 0 {
		defer atomic.StoreUint32(&o.done, 1)
		f()
	}
}

参考

• https://blog.csdn.net/grace_yi/article/details/103621450
• https://studygolang.com/articles/11444