面试题：Go语言sync.Once与其他语言类似机制的比较与优劣

实现原理

Java、C++懒汉式初始化：
- Java：通常通过在静态成员变量声明时不初始化，在第一次调用获取实例方法时进行初始化，并使用 synchronized关键字保证线程安全。例如：

public class Singleton {
    private static Singleton instance;
    private Singleton() {}
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

- **C++**：C++11 引入了局部静态变量的线程安全初始化机制，在函数内第一次调用时初始化。例如：

class Singleton {
private:
    Singleton() {}
public:
    static Singleton& getInstance() {
        static Singleton instance;
        return instance;
    }
};

Go语言的sync.Once：sync.Once结构体内部有一个done标志位和一个mutex互斥锁。Do方法首先检查done标志位，如果已经执行过初始化则直接返回；否则加锁再次检查done标志位（防止竞态条件下重复初始化），然后执行初始化函数，最后设置done标志位并解锁。例如：

package main

import (
    "fmt"
    "sync"
)

var instance *MyStruct
var once sync.Once

type MyStruct struct {
    data int
}

func GetInstance() *MyStruct {
    once.Do(func() {
        instance = &MyStruct{data: 10}
    })
    return instance
}

性能表现

Java、C++懒汉式初始化：
- Java：双重检查锁定机制（DCL）在高并发场景下，由于 synchronized关键字的存在，性能开销较大，每次获取实例都可能涉及到锁的竞争。不过，现代 JVM 对锁有一定优化。
- C++：C++11 局部静态变量初始化在多线程环境下性能较好，因为编译器保证了线程安全初始化，且只在第一次调用时初始化，后续获取实例没有锁开销。
Go语言的sync.Once：性能表现优秀，在初始化完成后，后续调用Do方法不再有锁的竞争，只进行简单的done标志位检查，开销极小。

适用场景

Java、C++懒汉式初始化：适用于单例模式等需要延迟初始化的场景。在Java中，DCL 常用于需要严格控制资源使用，延迟初始化的单例实现。在C++中，局部静态变量初始化适合在函数内需要唯一实例的场景。
Go语言的sync.Once：适用于在Go语言项目中任何需要延迟初始化且只执行一次的场景，如全局变量初始化、只需要执行一次的初始化任务等。

Go语言sync.Once的优势

简洁性：使用简单，只需定义一个sync.Once变量，调用Do方法传入初始化函数即可，代码结构清晰。
高性能：初始化完成后，后续调用几乎无性能开销，因为不再需要获取锁，只检查标志位。
通用性：不仅适用于单例模式，也可用于各种需要一次性初始化的场景，例如在包级别初始化一些资源。

Go语言sync.Once的劣势

功能单一：只能用于一次性初始化任务，相比Java、C++中一些更复杂的延迟初始化框架，功能相对局限。
学习成本：对于不熟悉Go语言并发模型的开发者，理解sync.Once的原理和使用可能需要一定学习成本。

星途面试题库

面试题：Go语言sync.Once与其他语言类似机制的比较与优劣

知识考点

面试题答案

实现原理

性能表现

适用场景

Go语言sync.Once的优势

Go语言sync.Once的劣势