面试题：Go语言sync.Once单例模式下的并发安全及性能优化

sync.Once多次初始化检查开销分析

原理：sync.Once通过一个done标志和一个互斥锁mu来实现单例模式。在调用Do方法时，首先检查done标志，如果已经初始化（done非0），则直接返回，不进行后续操作。如果done为0，则获取互斥锁，再次检查done（双重检查锁定），若仍未初始化则执行初始化函数，最后释放互斥锁并设置done标志。
开销：在高并发场景下，虽然第一次初始化时的锁竞争不可避免，但后续每次调用Do方法都要检查done标志，并且在未初始化时获取和释放互斥锁，即使已经初始化完成后仍有这些操作，这在高并发频繁调用Do时会带来额外的性能开销。

性能优化方法

基于sync.Once底层原理优化：
- 提前初始化：如果可能，在程序启动阶段就进行单例的初始化，这样可以避免在运行时的高并发环境下进行初始化操作，减少锁竞争。例如在Go语言的init函数中进行初始化。
- 双检查锁定优化：虽然sync.Once已经使用了双检查锁定机制，但可以进一步思考。在Go语言中，可以利用编译器的优化和CPU的缓存一致性协议来优化。在检查done标志时，由于现代CPU的缓存一致性，多个CPU核心上的缓存副本在done标志改变时能及时更新，减少不必要的锁竞争。
- 减少不必要的检查：可以通过自定义逻辑，在业务层面上判断是否需要调用sync.Once.Do。例如，根据业务逻辑提前确定是否已经初始化完成，如果已经确定初始化完成，就不再调用sync.Once.Do，从而减少不必要的done标志检查和锁操作。
使用其他技术：
- 基于init函数和包级变量：在Go语言中，包级变量会在包初始化时自动初始化，并且这个过程是并发安全的。如果单例对象的初始化不需要依赖运行时的动态数据，可以将其定义为包级变量并在包的init函数中初始化，这种方式避免了sync.Once的锁开销。例如：

package main

import "fmt"

var singletonInstance *MySingleton

func init() {
    singletonInstance = &MySingleton{}
}

type MySingleton struct {
    // 单例对象的具体字段
}

func GetSingleton() *MySingleton {
    return singletonInstance
}

延迟初始化结合读写锁：可以使用读写锁（sync.RWMutex）来实现类似单例的功能。在初始化前，读操作等待写操作完成，初始化完成后，读操作可以并发执行。这种方式在初始化完成后，读操作性能优于sync.Once，但实现稍微复杂。示例代码如下：

package main

import (
    "fmt"
    "sync"
)

type MySingleton struct {
    // 单例对象的具体字段
}

var (
    singletonInstance *MySingleton
    once              sync.Once
    rwMutex           sync.RWMutex
)

func GetSingleton() *MySingleton {
    rwMutex.RLock()
    if singletonInstance != nil {
        rwMutex.RUnlock()
        return singletonInstance
    }
    rwMutex.RUnlock()

    once.Do(func() {
        rwMutex.Lock()
        defer rwMutex.Unlock()
        if singletonInstance == nil {
            singletonInstance = &MySingleton{}
        }
    })
    return singletonInstance
}

这种方式在初始化后，读操作无需获取互斥锁，减少了性能开销，但增加了代码的复杂性，并且需要注意写操作时的同步问题，以保证单例模式和并发安全。

星途面试题库

面试题：Go语言sync.Once单例模式下的并发安全及性能优化

知识考点

面试题答案

sync.Once多次初始化检查开销分析

性能优化方法