Implémentation du cache Golang

Lors du développement d'un site Web ou d'une application, une page peut contenir différentes données et ressources qui doivent être chargées, dont certaines seront fréquemment demandées. Dans ce cas, interroger la base de données ou récupérer les ressources à chaque demande peut entraîner une réponse lente du site Web ou de l'application. Pour résoudre ce problème, nous pouvons utiliser la technologie de mise en cache. Cet article explique comment implémenter la mise en cache dans Golang.

Mise en cache dans Golang

Il existe un package dans Golang appelé "sync", qui contient une implémentation de carte sécurisée pour la concurrence de type "Map". Nous pouvons utiliser cette carte pour implémenter la fonctionnalité de mise en cache.

Voici les étapes de base pour implémenter la mise en cache dans Golang :

1. Définir une variable globale

Nous pouvons définir une variable Map globale pour stocker les données mises en cache. Dans cette carte, nous pouvons utiliser des chaînes comme « clés » et tout type de variables comme « valeurs ».

var cache = struct {
    sync.RWMutex
    items map[string]interface{}
}{
    items: make(map[string]interface{}),
}

Dans le code ci-dessus, la structure sync.RWMutex est utilisée pour garantir que l'opération de cache est thread-safe. En même temps, la fonction make est utilisée pour créer une Map vide.

2. Ajouter des données au cache

func Set(key string, value interface{}, exp time.Duration) {
    cache.Lock()
    defer cache.Unlock()
    cache.items[key] = value
    if exp > 0 {
        time.AfterFunc(exp, func() {
            expire(key)
        })
    }
}

Dans le code ci-dessus, nous utilisons la méthode "Lock" pour garantir que le cache est à l'abri de plusieurs goroutines qui y accèdent en même temps. Après cela, nous avons ajouté une paire clé-valeur au cache, où « clé » est la clé mise en cache et « valeur » est la valeur mise en cache. Enfin, nous utilisons la fonction "time.AfterFunc" pour définir l'heure du cache. Lorsque le cache expire, la méthode "expire" est automatiquement appelée pour supprimer le cache.

3. Lecture des données du cache

func Get(key string) (interface{}, bool) {
    cache.RLock()
    defer cache.RUnlock()
    val, ok := cache.items[key]
    return val, ok
}

Dans le code ci-dessus, nous utilisons la méthode "RLock" pour verrouiller le cache afin de garantir que plusieurs goroutines y accédant simultanément peuvent lire librement les données mises en cache. Ensuite, nous récupérons la paire clé-valeur correspondante du cache. "val" est la valeur récupérée et "ok" indique si le cache a été récupéré avec succès.

4. Suppression des données du cache

func Delete(key string) {
    cache.Lock()
    defer cache.Unlock()
    delete(cache.items, key)
}

Dans le code ci-dessus, nous utilisons la méthode "Lock" pour garantir que le cache est sécurisé pour plusieurs goroutines qui y accèdent simultanément. Ensuite, supprimez la paire clé-valeur correspondante dans le cache.

Exemple de code

Selon les étapes ci-dessus, nous pouvons écrire une implémentation de cache simple, le code est le suivant :

package main

import (
    "fmt"
    "sync"
    "time"
)

var cache = struct {
    sync.RWMutex
    items map[string]interface{}
}{
    items: make(map[string]interface{}),
}

func Set(key string, value interface{}, exp time.Duration) {
    cache.Lock()
    defer cache.Unlock()
    cache.items[key] = value
    if exp > 0 {
        time.AfterFunc(exp, func() {
            expire(key)
        })
    }
}

func Get(key string) (interface{}, bool) {
    cache.RLock()
    defer cache.RUnlock()
    val, ok := cache.items[key]
    return val, ok
}

func Delete(key string) {
    cache.Lock()
    defer cache.Unlock()
    delete(cache.items, key)
}

func expire(key string) {
    cache.Lock()
    defer cache.Unlock()
    delete(cache.items, key)
}

func main() {
    Set("key", "value", time.Second*10)

    val, ok := Get("key")
    if ok {
        fmt.Println(val)
    } else {
        fmt.Println("Value not found")
    }

    Delete("key")
}

Dans l'exemple ci-dessus, nous utilisons la méthode Set pour ajouter une paire clé-valeur au cache et définir l'heure du cache. Ensuite, utilisez la méthode Get pour lire la valeur stockée dans le cache. Enfin, utilisez la méthode Supprimer pour supprimer les paires clé-valeur stockées.

Conclusion

Dans cet article, nous avons présenté la méthode d'utilisation du package Sync pour implémenter la mise en cache dans Golang. Cette méthode peut être utilisée pour améliorer l’efficacité des données d’exploitation et réduire les requêtes inutiles dans la base de données. J'espère que cet article pourra vous aider à mieux comprendre comment la mise en cache est implémentée dans Golang.

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!