Wie gehe ich mit der Ungültigmachung des Golang-Cache um?

Beim Umgang mit der Cache-Ungültigmachung in Golang können Sie die folgende Strategie verfolgen: Markieren Sie Cache-Elemente mit Zeitstempeln und erhalten Sie neue Daten, wenn sie ablaufen. Mithilfe von Sperren wird der Cache gesperrt, wenn die Coroutine das Cache-Element erhält, und der Cache wird entsperrt und neue Daten werden abgerufen, wenn das Cache-Element nicht vorhanden ist oder abläuft.

Wie gehe ich mit einem Golang-Cache-Fehler um?

Bei der Verwendung von Cache in Golang-Programmen ist es wichtig, mit Cache-Fehlern umzugehen, um Datenkonsistenz und -zuverlässigkeit sicherzustellen. Es gibt zwei Verarbeitungsstrategien:

1. Verwenden Sie Zeitstempel

• , um Cache-Elemente mit Zeitstempeln zu verknüpfen.
• Wenn das Cache-Element abläuft, rufen Sie neue Daten ab und aktualisieren Sie den Cache.

type CacheItem struct {
    Value interface{}
    Timestamp time.Time
}

var cache = make(map[string]CacheItem)

func SetCache(key string, value interface{}) {
    cache[key] = CacheItem{Value: value, Timestamp: time.Now()}
}

func GetCache(key string) (interface{}, bool) {
    item, ok := cache[key]
    if ok && time.Since(item.Timestamp) < time.Second*30 {
        return item.Value, true
    }
    return nil, false
}

2. Sperren verwenden

• Wenn eine Coroutine Cache-Elemente erhält, sperren Sie den Cache.
• Wenn das Cache-Element nicht existiert oder abgelaufen ist, entsperren Sie den Cache und erhalten Sie neue Daten.

var cache = sync.Map{}

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

func GetCache(key string) (interface{}, bool) {
    if value, ok := cache.Load(key); ok {
        return value, true
    }

    lock := sync.Mutex{}
    lock.Lock()
    defer lock.Unlock()

    if value, ok := cache.Load(key); ok {
        return value, true
    }

    newValue, err := fetchNewValue(key)
    if err == nil {
        cache.Store(key, newValue)
    }

    return newValue, err == nil
}

Praktischer Fall

Angenommen, wir verwenden Cache in einer RESTful-API, um Benutzerdetails zu speichern.

package main

import (
    "encoding/json"
    "fmt"
    "net/http"
    "time"

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

var redisClient = redis.NewClient(&redis.Options{})

type User struct {
    ID   int
    Name string
}

func main() {
    // 添加缓存处理
    http.HandleFunc("/users/:id", func(w http.ResponseWriter, r *http.Request) {
        var user User
        id := r.URL.Path[len("/users/"):]

        // 尝试从缓存中获取用户数据
        cachedUser, ok := GetCache(id)
        if ok {
            // 缓存命中
            fmt.Fprintf(w, "User from cache: %+v", cachedUser)
            return
        }

        // 缓存未命中
        // 从数据库中获取用户数据
        err := db.Get(id, &user)
        if err != nil {
            // 数据库中不存在此用户
            fmt.Fprintf(w, "User not found")
            return
        }

        // 设置缓存，有效期为 30 秒
        SetCache(id, user, time.Second*30)
        fmt.Fprintf(w, "User from database: %+v", user)
    })

    http.ListenAndServe(":8080", nil)
}

func GetCache(key string) (User, bool) {
    result, err := redisClient.Get(key).Bytes()
    if err != nil {
        return User{}, false
    }

    var user User
    err = json.Unmarshal(result, &user)
    if err != nil {
        return User{}, false
    }

    return user, true
}

func SetCache(key string, user User, expiration time.Duration) {
    jsonBytes, err := json.Marshal(user)
    if err != nil {
        return
    }

    err = redisClient.Set(key, jsonBytes, expiration).Err()
    if err != nil {
        return
    }
}

Das obige ist der detaillierte Inhalt vonWie gehe ich mit der Ungültigmachung des Golang-Cache um?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!