Go中写一次读多次全局变量的实现优化及相关疑问

我想实现一个全局变量，首次读取时通过API写入，后续读取无需加锁。目前已经写出了实现代码，但觉得太繁琐，有以下几个疑问：

1. Go语言中这类场景有没有常规实现方式？
2. 如果有多个这类全局变量，又不想把它们放在同一个结构体里，怎么避免代码重复？
3. 已知sync/atomic只支持整数类型的原子操作，社区里是怎么处理string类型的？
   另外，用sync.Once的时候，如果首次获取失败，程序就再也拿不到clusterName了，而且不知道怎么让其他等待的读者等到sync.Once执行完成，求解决方案。

附实现代码：

package main

import (
    "fmt"
    "sync"
    "time"
)

type ClusterName struct {
    sync.RWMutex
    clusterName string
}

// Global variable. Read-many, write once.
var clusterName ClusterName

// Method to avoid locking during reads if 'clusterName' has been filled once.
func GetClusterName() (string, error) {
    // Take read lock to see if 'clusterName' is filled.
    clusterName.RLock()
    if clusterName.clusterName == "" {
        // 'clusterName' is not filled. Release read-lock and call method to fill it with write-lock.
        clusterName.RUnlock()
        return getClusterName()
    }

    defer clusterName.RUnlock()
    return clusterName.clusterName, nil
}

// Method to fetch and fill cluster name. Takes a write-lock.
func getClusterName() (string, error) {
    // Take write-lock.
    clusterName.Lock()
    defer clusterName.Unlock()

    // See if previous writer has already filled this. Just return if already filled.
    if clusterName.clusterName != "" {
        return clusterName.clusterName, nil
    }

    // Only 1 writer will ever reach here.
    var err error
    clusterName.clusterName, err = fetchClusterName()
    if err != nil {
        return "", err
    }

    return clusterName.clusterName, nil
}

func fetchClusterName() (string, error) {
    // API call.
    time.Sleep(time.Second)
    return "test-cluster-name", nil
}

func main() {
    for i := 0; i < 50; i++ {
        fmt.Println(GetClusterName())
    }
}

1. Go语言中此类场景的常规实现方式 #

最常规的方案是基于sync.Once封装支持错误重试的逻辑，或者使用双重检查锁（你当前的实现就是这类），其中sync.Once是标准库提供的更简洁方案，但需要处理失败重试和等待问题。

针对sync.Once的缺陷，可封装一个带错误处理的重试版Once：

import (
    "sync"
    "sync/atomic"
)

type OnceWithRetry struct {
    mu    sync.Mutex
    done  uint32
    err   error
    value string
}

func (o *OnceWithRetry) Do(f func() (string, error)) (string, error) {
    // 先原子检查是否已成功加载
    if atomic.LoadUint32(&o.done) == 1 {
        return o.value, o.err
    }

    // 加锁确保唯一执行加载
    o.mu.Lock()
    defer o.mu.Unlock()

    // 二次检查，避免其他goroutine已完成加载
    if o.done == 0 {
        o.value, o.err = f()
        // 只有加载成功才标记完成
        if o.err == nil {
            atomic.StoreUint32(&o.done, 1)
        }
    }
    // 若加载失败，后续调用会重新进入锁内重试
    return o.value, o.err
}

这个结构既保证了首次加载的原子性，支持失败后重试，同时所有等待的goroutine会通过锁等待加载操作完成。

2. 多个全局变量避免代码重复的方式 #

用泛型封装通用懒加载结构体，让不同类型的全局变量复用同一套逻辑：

import (
    "sync"
    "sync/atomic"
)

type LazyLoader[T any] struct {
    mu    sync.Mutex
    done  uint32
    value T
    err   error
    load  func() (T, error)
}

func NewLazyLoader[T any](load func() (T, error)) *LazyLoader[T] {
    return &LazyLoader[T]{load: load}
}

func (l *LazyLoader[T]) Get() (T, error) {
    if atomic.LoadUint32(&l.done) == 1 {
        return l.value, l.err
    }

    l.mu.Lock()
    defer l.mu.Unlock()

    if l.done == 0 {
        l.value, l.err = l.load()
        if l.err == nil {
            atomic.StoreUint32(&l.done, 1)
        }
    }
    return l.value, l.err
}

// 使用示例
var clusterNameLoader = NewLazyLoader(func() (string, error) {
    return fetchClusterName()
})

var regionLoader = NewLazyLoader(func() (string, error) {
    return "us-east-1", nil
})

func GetClusterName() (string, error) {
    return clusterNameLoader.Get()
}

func GetRegion() (string, error) {
    return regionLoader.Get()
}

通过泛型，不管是string、int还是自定义类型，都可以复用LazyLoader的逻辑，无需重复编写锁和检查代码。

3. 社区处理string类型原子操作的方式 #

因为Go中string是不可变类型，社区常用两种方式实现原子操作：

• 使用atomic.Value：支持存储任意类型，通过Load/Store实现原子操作：

import "sync/atomic"

var clusterName atomic.Value

func GetClusterName() (string, error) {
    if v := clusterName.Load(); v != nil {
        return v.(string), nil
    }
    // 双重检查锁加载
    mu.Lock()
    defer mu.Unlock()
    if v := clusterName.Load(); v != nil {
        return v.(string), nil
    }
    name, err := fetchClusterName()
    if err != nil {
        return "", err
    }
    clusterName.Store(name)
    return name, nil
}

• 使用atomic.Pointer[string]（Go 1.19+）：类型更安全，无需类型断言：

import "sync/atomic"

var clusterName atomic.Pointer[string]

func GetClusterName() (string, error) {
    if v := clusterName.Load(); v != nil {
        return *v, nil
    }
    mu.Lock()
    defer mu.Unlock()
    if v := clusterName.Load(); v != nil {
        return *v, nil
    }
    name, err := fetchClusterName()
    if err != nil {
        return "", err
    }
    clusterName.Store(&name)
    return name, nil
}

关于sync.Once的失败重试和等待问题 #

默认sync.Once仅执行一次传入函数，哪怕函数失败。解决这个问题的核心是：

1. 用原子变量标记是否成功加载，而非仅标记是否执行过函数
2. 加锁确保只有一个goroutine执行加载操作
3. 失败后不标记"完成"，后续调用可重新进入锁内重试
4. 所有等待的goroutine通过锁等待加载操作完成，无论成功或失败

前面的OnceWithRetry结构体已经实现了这个逻辑，既保证并发安全，又解决了首次失败无法重试、读者等待的问题。

内容的提问来源于stack exchange，提问作者subtleseeker