Pratique consistant à combiner le cache de fonctions Golang et le stockage tiers

La mise en cache des fonctions est une technologie d'optimisation utilisée pour éviter les calculs répétés et améliorer les performances. Lorsque la taille du cache dépasse la limite de mémoire, la capacité du cache peut être étendue en combinant un stockage tiers, par exemple en utilisant Redis. En pratique, un grand nombre de résultats de requêtes peuvent être mis en cache dans Redis, améliorant ainsi considérablement les performances.

Pratique consistant à combiner le cache de fonctions Golang avec un stockage tiers

Le cache de fonctions est une technologie d'optimisation utilisée pour éviter les calculs répétés et améliorer les performances des applications. Dans Golang, le package sync/syncmap fournit une implémentation simple du cache de fonctions. Toutefois, pour les applications gourmandes en cache, il peut être nécessaire de tirer parti du stockage tiers pour étendre la capacité du cache.

Utilisez sync/syncmap pour une mise en cache simple

import (
    "sync"
)

var cache = sync.Map{}

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

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

Développez le stockage tiers

Lorsque la taille du cache dépasse la limite de mémoire, la capacité du cache peut être étendue en combinant le stockage tiers. Un exemple d'utilisation de Redis comme backend de stockage est présenté ici :

import (
    "context"
    "sync"
    "time"

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

// 将 sync/syncmap 作为一级缓存
var cache = sync.Map{}

// 使用 Redis 作为二级缓存
var redisClient = redis.NewClient(&redis.Options{
    Addr:     "localhost:6379",
    Password: "",
    DB:       0,
})

// 设置缓存超时时间（秒）
var cacheTimeout = 600

// 从一级缓存获取数据，如果没有则从 Redis 获取并设置到一级缓存中
func Get(key string) (interface{}, bool) {
    if val, ok := cache.Load(key); ok {
        return val, true
    }

    val, err := redisClient.Get(context.Background(), key).Result()
    if err != nil {
        return nil, false
    }

    cache.Store(key, val)
    return val, true
}

// 设置缓存数据，同时存储到 Redis 中
func Set(key string, value interface{}) {
    cache.Store(key, value)
    expireCtx := context.Background()
    if err := redisClient.Set(expireCtx, key, value, cacheTimeout*time.Second).Err(); err != nil {
        // 处理可能的错误
    }
}

Exemple pratique : mise en cache d'un grand nombre de résultats de requêtes

Supposons qu'il existe une application qui doit effectuer un grand nombre de mêmes requêtes de base de données. Pour optimiser les performances, la mise en cache des fonctions peut être exploitée pour éviter les requêtes répétées. Cependant, en raison du grand ensemble de résultats de requête, le stockage de tous les résultats en mémoire dépasserait la mémoire disponible.

Grâce au cache de fonctions combiné au stockage tiers, les résultats des requêtes fréquentes peuvent être stockés dans Redis. De cette façon, même si les limites de mémoire sont dépassées, les applications peuvent toujours accéder rapidement à ces résultats, améliorant ainsi considérablement les performances.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!