Sperrfreie Read-Copy-Update (RCU) Strategie mit atomic.Value

package main
 
import (
	"fmt"
	"sync"
	"sync/atomic"
)
 
type MapConfig map[string]string
 
type ConfigManager struct {
	current atomic.Value // Stores MapConfig
	wmu     sync.Mutex   // Serializes write updates
}
 
func NewConfigManager(initial MapConfig) *ConfigManager {
	cm := &ConfigManager{}
	cm.current.Store(initial)
	return cm
}
 
func (cm *ConfigManager) Get(key string) string {
	m := cm.current.Load().(MapConfig)
	return m[key]
}
 
func (cm *ConfigManager) Update(key, val string) {
	cm.wmu.Lock()
	defer cm.wmu.Unlock()
 
	// Read current map, clone it, and swap atomically
	currMap := cm.current.Load().(MapConfig)
	newMap := make(MapConfig, len(currMap)+1)
	for k, v := range currMap {
		newMap[k] = v
	}
	newMap[key] = val
 
	cm.current.Store(newMap)
}
 
func main() {
	cm := NewConfigManager(MapConfig{"env": "prod"})
	cm.Update("debug", "false")
	fmt.Println(cm.Get("env"), cm.Get("debug"))
}