Go语言线程安全可变配置的优雅实现方案咨询

问题背景 #

日常使用Viper管理配置，但在需要运行时修改配置的GUI场景中，Viper无法支持并发安全的读写操作。手动为每个配置字段的读写加解锁会导致代码冗余且容易出错，比如：

var config struct {
  lock sync.RWMutex
  myString string
  myInt int
}

func main() {
  config.lock.RLock()
  _ = config.myString // 读操作
  config.lock.RUnlock()
}

无冗余的解决方式 #

1. 封装专属Get/Set方法（推荐） #

将锁的逻辑封装在配置结构体的方法内部，外部调用无需关心锁的细节：

import "sync"

type Config struct {
    lock     sync.RWMutex
    myString string
    myInt    int
}

// GetMyString 线程安全的读取myString
func (c *Config) GetMyString() string {
    c.lock.RLock()
    defer c.lock.RUnlock()
    return c.myString
}

// SetMyString 线程安全的修改myString
func (c *Config) SetMyString(s string) {
    c.lock.Lock()
    defer c.lock.Unlock()
    c.myString = s
}

// GetMyInt 线程安全的读取myInt
func (c *Config) GetMyInt() int {
    c.lock.RLock()
    defer c.lock.RUnlock()
    return c.myInt
}

// SetMyInt 线程安全的修改myInt
func (c *Config) SetMyInt(i int) {
    c.lock.Lock()
    defer c.lock.Unlock()
    c.myInt = i
}

调用示例：

func main() {
    cfg := &Config{}
    
    // 写配置
    cfg.SetMyString("hello")
    cfg.SetMyInt(123)
    
    // 读配置
    s := cfg.GetMyString()
    i := cfg.GetMyInt()
}

这种方式的优势：

• 锁逻辑集中管理，避免重复代码
• 使用defer确保锁一定会被释放，即使方法内部发生panic
• 对外接口清晰，调用方无需关注并发细节

2. 函数式访问（适合复杂操作） #

如果需要对配置字段执行复杂的读取或修改操作，可以用函数式封装，把操作逻辑传入方法，由方法负责加解锁：

// ReadMyString 传入处理函数，在锁保护下执行读取操作
func (c *Config) ReadMyString(fn func(string)) {
    c.lock.RLock()
    defer c.lock.RUnlock()
    fn(c.myString)
}

// UpdateMyInt 传入更新函数，在锁保护下执行修改操作
func (c *Config) UpdateMyInt(fn func(int) int) {
    c.lock.Lock()
    defer c.lock.Unlock()
    c.myInt = fn(c.myInt)
}

调用示例：

// 复杂读取
cfg.ReadMyString(func(s string) {
    // 在这里可以对s执行任意操作，比如拼接、打印
    println("current string:", s)
})

// 基于旧值更新
cfg.UpdateMyInt(func(old int) int {
    return old + 1
})

这种方式适合需要依赖配置当前值做修改，或者一次性读取多个字段的场景，避免多次加解锁。

注意事项 #

• 避免直接暴露配置结构体的字段，强制通过方法访问，确保并发安全
• 读操作使用RLock()/RUnlock()，允许多个读操作并发执行，提升性能；写操作必须用Lock()/Unlock()，保证独占访问

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