十三. go 高性能编程之 sync.Once如何提升性能

一. sync.Once 使用场景与基础问题

1. sync.Once 是 Go 标准库提供的使函数只执行一次的实现，常应用于单例模式，例如初始化配置、保持数据库连接等
2. 与 init 函数区别:

1. init 函数是当所在的 package 首次被加载时执行，若迟迟未被使用，则既浪费了内存，又延长了程序加载时间。
2. sync.Once 可以在代码的任意位置初始化和调用，因此可以延迟到使用时再执行，并发场景下是线程安全的

3. 多数情况下sync.Once 被用于控制变量的初始化，这个变量的读写满足如下三个条件：

1. 当且仅当第一次访问某个变量时，进行初始化（写）；
2. 变量初始化过程中，所有读都被阻塞，直到初始化完成；
3. 变量仅初始化一次，初始化完成后驻留在内存里。

一个简单的使用 Demo

1. 如下代码

1. 代码中声明了 2 个全局变量，once 和 config
2. config这个变量是在ReadConfig()函数中初始化的
3. 但是ReadConfig() 可能会被并发调用多次
4. 问题: 如果 ReadConfig()被多次调用时,每次都构造出一个新的 Config 结构体，既浪费内存，又浪费初始化时间。如果 ReadConfig 中不加锁，初始化全局变量 config 就可能出现并发冲突
5. 所以使用sync.Once, 既能够保证全局变量初始化时是线程安全的，又能节省内存和初始化时间

type Config struct {
	Server string
	Port   int64
}

var (
	once   sync.Once
	config *Config
)

func ReadConfig() *Config {
	once.Do(func() {
		var err error
		config = &Config{Server: os.Getenv("TT_SERVER_URL")}
		config.Port, err = strconv.ParseInt(os.Getenv("TT_PORT"), 10, 0)
		if err != nil {
			config.Port = 8080 // default port
        }
        log.Println("init config")
	})
	return config
}

func main() {
	for i := 0; i < 10; i++ {
		go func() {
			_ = ReadConfig()
		}()
	}
	time.Sleep(time.Second)
}

sync.Once 在标准库中的使用

1. 在 go1.13.6 版本的源码目录下，可以 grep 到 111 处使用。比如 package html 中，对象 entity 只被初始化一次：

var populateMapsOnce sync.Once
var entity           map[string]rune

func populateMaps() {
    entity = map[string]rune{
        "AElig;":                           '\U000000C6',
        "AMP;":                             '\U00000026',
        "Aacute;":                          '\U000000C1',
        "Abreve;":                          '\U00000102',
        "Acirc;":                           '\U000000C2',
        // 省略 2000 项
    }
}

func UnescapeString(s string) string {
    populateMapsOnce.Do(populateMaps)
    i := strings.IndexByte(s, '&')

    if i < 0 {
            return s
    }
    // 省略后续的实现
}

二. sync.Once原理

1. 在实现sync.Once时要考虑两点

1. 首先：保证变量仅被初始化一次，需要有个标志来判断变量是否已初始化过，若没有则需要初始化。
2. 第二：线程安全，支持并发，无疑需要互斥锁来实现

2. 查看sync.Once 的源码: 使用变量 done 来记录函数的执行状态，使用 sync.Mutex 和 sync.atomic 来保证线程安全的读取 done

package sync

import (
    "sync/atomic"
)

type Once struct {
    done uint32
    m    Mutex
}

func (o *Once) Do(f func()) {
    // 原子加载标识值，判断是否已被执行过
	if atomic.LoadUint32(&o.done) == 0 {
		o.doSlow(f)
	}
}

//执行函数
func (o *Once) doSlow(f func()) { 
	o.m.Lock()
	defer o.m.Unlock()
	if o.done == 0 { // 再次判断下是否已被执行过函数
		defer atomic.StoreUint32(&o.done, 1) // 原子操作：修改标识值
		f() // 执行函数
	}
}

3. 在执行Once的Do()方法时,首先会执行atomic.LoadUint32(&o.done),判断done 是否等于0,不等于说明已经执行过完毕, 等于0,说明未被执行过,调用doSlow()执行函数开始执行函数,在doSlow()中会再次通过done判断执行状态,然后执行atomic.StoreUint32通过原子操作修改执行标识,然后执行传递的函数

done 为什么是第一个字段

1. 查看sync.Once底层Once结构体中的done属性: done 在热路径中，done 放在第一个字段，能够减少 CPU 指令，也就是说，这样做能够提升性:

1. 热路径(hot path)是程序非常频繁执行的一系列指令，sync.Once 绝大部分场景都会访问 o.done，在热路径上是比较好理解的，如果 hot path 编译后的机器码指令更少，更直接，必然是能够提升性能的。
2. 为什么放在第一个字段就能够减少指令呢？因为结构体第一个字段的地址和结构体的指针是相同的，如果是第一个字段，直接对结构体的指针解引用即可。如果是其他的字段，除了结构体指针外，还需要计算与第一个值的偏移(calculate offset)。在机器码中，偏移量是随指令传递的附加值，CPU 需要做一次偏移值与指针的加法运算，才能获取要访问的值的地址。因为，访问第一个字段的机器代码更紧凑，速度更快