Golang新手如何处理并发数据库请求中的重复数据问题

我认为事情并非那么简单。本质上，服务器默认会缓存请求，但当数据库中的数据发生变化时，缓存必须刷新，这通常发生在下一次请求时，从而导致性能下降。我们的想法是由另一方来维护并定期更新缓存。

在并发场景下处理重复数据库请求，典型的解决方案是使用sync.Map配合sync.Once或通道。以下是针对你问题的具体实现：

type cacheEntry struct {
    once  sync.Once
    value interface{}
    err   error
}

type QueryCache struct {
    m sync.Map
}

func (c *QueryCache) GetOrLoad(key string, loadFn func() (interface{}, error)) (interface{}, error) {
    entry, loaded := c.m.LoadOrStore(key, &cacheEntry{})
    e := entry.(*cacheEntry)
    
    if !loaded {
        e.once.Do(func() {
            e.value, e.err = loadFn()
        })
    } else {
        // 等待其他goroutine完成加载
        e.once.Do(func() {}) // 等待已经运行的once完成
    }
    
    return e.value, e.err
}

// 使用示例
var globalCache = &QueryCache{}

func queryHandler(w http.ResponseWriter, r *http.Request) {
    // 获取参数
    x := r.URL.Query().Get("x")
    y := r.URL.Query().Get("y")
    z := r.URL.Query().Get("z")
    
    query, key := formQuery(x, y, z)
    
    data, err := globalCache.GetOrLoad(key, func() (interface{}, error) {
        // 这个函数只会执行一次
        return queryDatabaseAndCacheTheResult(query, key)
    })
    
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    
    processDataForDisplay(w, data)
}

func queryDatabaseAndCacheTheResult(query, key string) (interface{}, error) {
    // 模拟耗时数据库查询
    time.Sleep(30 * time.Second)
    return fmt.Sprintf("Result for %s", query), nil
}

更完整的实现可以加入缓存过期机制：

type cacheEntryWithExpiry struct {
    once      sync.Once
    value     interface{}
    err       error
    timestamp time.Time
    expiry    time.Duration
}

type QueryCacheWithExpiry struct {
    m sync.Map
}

func (c *QueryCacheWithExpiry) GetOrLoad(key string, expiry time.Duration, loadFn func() (interface{}, error)) (interface{}, error) {
    now := time.Now()
    
    entry, loaded := c.m.Load(key)
    if loaded {
        e := entry.(*cacheEntryWithExpiry)
        if now.Sub(e.timestamp) < expiry {
            return e.value, e.err
        }
        // 缓存过期，删除旧条目
        c.m.Delete(key)
    }
    
    newEntry := &cacheEntryWithExpiry{expiry: expiry}
    actual, loaded := c.m.LoadOrStore(key, newEntry)
    e := actual.(*cacheEntryWithExpiry)
    
    if !loaded {
        e.once.Do(func() {
            e.value, e.err = loadFn()
            e.timestamp = now
        })
    } else {
        e.once.Do(func() {})
    }
    
    return e.value, e.err
}

这种实现确保了：

1. 相同key的并发请求只执行一次数据库查询
2. 后续请求等待第一个请求完成
3. 支持缓存过期机制
4. 避免了缓存击穿问题