版本 0.02

在服务运行期间，针对所有goroutine共用一份数据的情况，比如配置信息，都可以选择只读取一次配置文件。但还是要特别注意：

1. 单例中不要保存只属于具体的goroutine的数据，否则会出现相互覆盖的情况。
2. 单例中使用的具体业务数据要通过参数的形式传递，避免有成员变量存在。

单例也是Lazy Initialization的一种，对于经常不使用的变量，只有在使用的时候才进行实例化，整体来说，还是节约资源的。

或者类似net/http中的client这种类型：

Clients and Transports are safe for concurrent use by multiple goroutines and for efficiency should only be created once and re-used.

sync.Once简介

Go语言通过sync包可以方便的实现线程安全的单例模式。最叹为观止的是，sync包的实现如此简单。通常用来处理在服务运行期间，只需要初始化一次的变量。

// Once is an object that will perform exactly one action.
type Once struct {
	m    Mutex
	done uint32
}

func (o *Once) Do(f func()) {
	if atomic.LoadUint32(&o.done) == 1 {
		return
	}
	// Slow-path.
	o.m.Lock()
	defer o.m.Unlock()
	if o.done == 0 {
		defer atomic.StoreUint32(&o.done, 1)
		f()
	}
}

sync.Once设计思路

举个例子：

下面声明统一获取配置类的函数，因为配置信息在整个服务运行期间是不会发生改变的。函数通过判断config是否被初始化，来达到只初始化一次的目的。例子中config声明为map的数据结构，来存储配置信息（map不支持并发访问，这里先忽略）。

package encrypt_config

//key-secret pairs
var config map[string]string

func loadConfig(name string) string {
	if config == nil {
		config = map[string]string{
			"zi-ru": "Mji9##a0LY",
			"baidu": "Kj8*0okhHH",
		}
	}
	return config[name]
}

代码最显而易见的问题：并发的情况下，包内变量config被初始化多次。因为各个goroutine访问config时可能都是nil。

但还存在一种可能的情况：goroutine B发现config ！= nil，但是当通过name去获取对应的值时，返回的却是空字符串。也就是说goroutine A访问到了一个没有被完全初始化的config

reason

Go在执行上述方法的时候，编译器在不影响最终结果的情况下，本身可以调整代码执行的顺序。这也是现在计算机多核处理，共享内存必然要面临的情况。比如编译器做了如下调整：

func loadConfig(name string) string {
	if config == nil {
	
	    //goroutine B 访问的时候，config刚被初始化 
	    config = make(map[string]string)
	    config["zi-ru"] = "Mji9##a0LY"
	    config["baidu"] = "Kj8*0okhHH"
	}
	return config[name]
}

问题的本质在于：goroutine B访问到了第一个goroutine A正在初始化的变量。而sync通过声明done标识，在配合Mutex锁，巧妙的实现了隔离。保证在config在初始化过程中，别的goroutine是不可访问的。

下面是在 双重检查锁定与延迟初始化 的一段内容：

根据《The Java Language Specification, Java SE 7 Edition》（后文简称为 java 语言规范），所有线程在执行 java 程序时必须要遵守 intra-thread semantics。intra-thread semantics 保证重排序不会改变单线程内的程序执行结果。换句话来说，intra-thread semantics 允许那些在单线程内，不会改变单线程程序执行结果的重排序。

lock

Lock

// Lock locks m.
// If the lock is already in use, the calling goroutine
// blocks until the mutex is available.
func (m *Mutex) Lock() {
	// Fast path: grab unlocked mutex.
	if atomic.CompareAndSwapInt32(&m.state, 0, mutexLocked) {
		if race.Enabled {
			race.Acquire(unsafe.Pointer(m))
		}
		return
	}
    ......

---

参考文章：

1. 双重检查锁定与延迟初始化