Go单例模式通过包级变量和同步机制实现，常见方式包括：1. 懒汉模式（非线程安全）；2. 加锁的懒汉模式；3. sync.Once推荐方式；4. 饿汉模式；5. atomic无锁实现。sync.Once最常用，兼顾安全与性能。

在Go语言中，单例模式是一种确保某个类型仅有一个实例，并提供一个全局访问点的设计模式。由于Go没有类的概念，也没有构造函数的私有化机制，因此实现单例需要借助包级变量、同步控制和延迟初始化等手段。以下是几种常见的Golang单例模式实现方式。

1. 懒汉模式（非并发安全）

懒汉模式指的是在第一次调用时才创建实例，适用于不频繁使用或资源消耗较大的对象。

注意：此版本在多协程环境下不安全，可能产生多个实例。

实现代码：

Golang Uber Dig

使用 uber-go/dig 在 Golang 中实现依赖注入——基于反射容器，提供 Provide/Invoke、dig.In/dig.Out 参数与结果对象，支持命名依赖等

下载

var instance *Singleton

type Singleton struct{}

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

2. 懒汉模式 + sync.Mutex（并发安全）

通过sync.Mutex保证多协程下只创建一次实例。

立即学习“go语言免费学习笔记（深入）”；

实现代码：

var (
    instance *Singleton
    mu       sync.Mutex
)

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

虽然安全，但每次调用都加锁会影响性能。

3. 懒汉模式 + sync.Once（推荐）

Go标准库中的sync.Once能确保某个函数只执行一次，非常适合单例初始化。

实现代码：

var (
    instance *Singleton
    once     sync.Once
)

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

这是最常用且推荐的方式，简洁、线程安全、性能良好。

4. 饿汉模式（包初始化时创建）

在包加载时就创建实例，利用Go的包级变量初始化机制，天然并发安全。

实现代码：

var instance = &Singleton{}

type Singleton struct{}

func GetInstance() *Singleton {
    return instance
}

优点是简单、安全；缺点是即使未使用也会被创建，可能浪费资源。

5. 使用sync/atomic实现无锁单例（高级用法）

结合atomic包实现轻量级状态控制，避免锁开销。

实现代码：

var (
    instance    *Singleton
    initialized uint32
)

func GetInstance() *Singleton {
    if atomic.LoadUint32(&initialized) == 1 {
        return instance
    }
    mu.Lock()
    defer mu.Unlock()
    if initialized == 0 {
        instance = &Singleton{}
        atomic.StoreUint32(&initialized, 1)
    }
    return instance
}

这种方式称为“双重检查锁定”，在高并发场景下性能更优，但代码略复杂。

基本上就这些常见实现方式。对于大多数项目，推荐使用 sync.Once 方式，它兼顾了安全性、简洁性和性能。饿汉模式适合启动快、必用的组件，而复杂的高并发服务可考虑原子操作优化。选择哪种方式取决于具体需求和资源初始化成本。