深度剖析 Go 语言在分布式缓存开发中的常见技术问题

var cache = sync.Map{}

func Get(key string) (interface{}, bool) {
    return cache.Load(key)
}

func Set(key string, value interface{}) {
    cache.Store(key, value)
}

type ShardedMap struct {
    shards []*sync.RWMutex
    data   []map[string]interface{}
}

func NewShardedMap(size int) *ShardedMap {
    sm := &ShardedMap{
        shards: make([]*sync.RWMutex, size),
        data:   make([]map[string]interface{}, size),
    }
    for i := 0; i < size; i++ {
        sm.shards[i] = &sync.RWMutex{}
        sm.data[i] = make(map[string]interface{})
    }
    return sm
}

func (sm *ShardedMap) Get(key string) (interface{}, bool) {
    shard := sm.shard(key)
    shard.RLock()
    defer shard.RUnlock()
    value, ok := sm.data[shardIndex(key, len(sm.shards))][key]
    return value, ok
}

func (sm *ShardedMap) Set(key string, value interface{}) {
    shard := sm.shard(key)
    shard.Lock()
    defer shard.Unlock()
    sm.data[shardIndex(key, len(sm.shards))][key] = value
}

func (sm *ShardedMap) shard(key string) *sync.RWMutex {
    return sm.shards[shardIndex(key, len(sm.shards))]
}

func shardIndex(key string, numShards int) int {
    return int(fnv.New32().Sum32([]byte(key))) % numShards
}

func UpdateCacheAndDB(key string, value interface{}) error {
    // 先更新数据库
    err := updateDB(key, value)
    if err != nil {
        return err
    }

    // 然后更新缓存
    err = updateCache(key, value)
    if err != nil {
        // 如果更新缓存失败，尝试回滚数据库
        rollbackDB(key)
        return err
    }

    return nil
}

func updateDB(key string, value interface{}) error {
    // 数据库更新逻辑
    return nil
}

func updateCache(key string, value interface{}) error {
    // 缓存更新逻辑
    return nil
}

func rollbackDB(key string) {
    // 数据库回滚逻辑
}

import "github.com/go-redis/redis/v8"

var redisClient = redis.NewClient(&redis.Options{
    Addr: "localhost:6379",
})

func UpdateCacheAndDBWithLock(key string, value interface{}) error {
    lock := redisClient.SetNX(ctx, "lock:"+key, "locked", 10*time.Second)
    if lock.Err() != nil {
        return lock.Err()
    }
    if !lock.Val() {
        return errors.New("failed to acquire lock")
    }
    defer redisClient.Del(ctx, "lock:"+key)

    err := updateDB(key, value)
    if err != nil {
        return err
    }

    err = updateCache(key, value)
    if err != nil {
        rollbackDB(key)
        return err
    }

    return nil
}

func UpdateCacheAndDBAsync(key string, value interface{}) {
    go func() {
        err := updateDB(key, value)
        if err != nil {
            log.Printf("Failed to update DB: %v", err)
            return
        }

        err = updateCache(key, value)
        if err != nil {
            log.Printf("Failed to update cache: %v", err)
        }
    }()
}

var bufferPool = sync.Pool{
    New: func() interface{} {
        return bytes.NewBuffer(make([]byte, 0, 1024))
    },
}

func GetBuffer() *bytes.Buffer {
    return bufferPool.Get().(*bytes.Buffer)
}

func PutBuffer(buf *bytes.Buffer) {
    buf.Reset()
    bufferPool.Put(buf)
}