Comment utiliser la mise en cache dans Go ?

La mise en cache est une technologie couramment utilisée en informatique qui peut améliorer efficacement les performances du système et la vitesse de réponse. Dans le langage Go, il existe de nombreuses implémentations de cache différentes, telles que sync.Map, map, LRU Cache, Redis, etc. Pour différents scénarios d'utilisation et exigences, nous devons choisir différentes solutions de mise en cache. Dans cet article, nous discuterons des connaissances et techniques pertinentes pour utiliser la mise en cache dans Go.

Implémentation du cache en langage Go

En Go, nous pouvons utiliser map pour implémenter un cache de base. Par exemple, nous pouvons définir un mappage pour mapper une URL sur un tableau d'octets de son contenu de réponse, puis lors du traitement d'une requête HTTP, vérifier si la réponse correspondant à l'URL existe dans le cache. Si elle existe, renvoyer directement la réponse. contenu dans le cache, sinon à partir de Obtenez les données de réponse de la source de données d'origine et ajoutez-les au cache. Voici un exemple d'implémentation :

package main

import (
    "fmt"
    "sync"
)

var cache = struct {
    sync.RWMutex
    data map[string][]byte
}{data: make(map[string][]byte)}


func main() {

    url := "https://www.example.com"
    if res, ok := get(url); ok {
        fmt.Println("cache hit")
        fmt.Println(string(res))
    } else {
        fmt.Println("cache miss")

        // fetch response from url
        res := fetchContent(url)
        set(url, res)
        fmt.Println(string(res))
    }
}

func get(key string) ([]byte, bool) {
    cache.RLock()
    defer cache.RUnlock()
    if res, ok := cache.data[key]; ok {
        return res, true
    }
    return nil, false
}

func set(key string, value []byte) {
    cache.Lock()
    defer cache.Unlock()
    cache.data[key] = value
}

func fetchContent(url string) []byte {
    // fetch content from url
    // ...
}

Dans l'exemple de code ci-dessus, nous définissons d'abord une variable globale nommée cache, qui possède un verrou en lecture-écriture et une carte pour stocker la relation de mappage entre l'URL et son contenu de réponse. Ensuite, lors du traitement de la requête HTTP, nous utilisons la fonction get pour obtenir la réponse du cache et la renvoyons directement si elle existe. Sinon, nous utilisons la fonction fetchContent pour obtenir les données de réponse de la source de données d'origine et les ajouter à. la cache.

En plus d'utiliser map, le langage Go fournit également d'autres implémentations de cache, telles que sync.Map et LRU Cache.

sync.Map est une carte thread-safe qui peut effectuer des opérations de lecture et d'écriture simultanées entre plusieurs goroutines sans verrouillage. L'utilisation de sync.Map pour implémenter la mise en cache peut améliorer les performances de concurrence du système. Voici un exemple d'implémentation :

package main

import (
    "fmt"
    "sync"
)

func main() {
    m := sync.Map{}
    m.Store("key1", "value1")
    m.Store("key2", "value2")

    if res, ok := m.Load("key1"); ok {
        fmt.Println(res)
    }
    m.Range(func(k, v interface{}) bool {
        fmt.Printf("%v : %v
", k, v)
        return true
    })
}

Dans l'exemple de code ci-dessus, nous stockons les données dans la carte en appelant la méthode Store de sync.Map et obtenons les données de la carte à l'aide de la méthode Load. De plus, nous pouvons également utiliser la méthode Range pour implémenter la fonction de parcours de la carte.

Le cache LRU est une stratégie de mise en cache courante qui utilise l'algorithme le moins récemment utilisé (Least Récemment utilisé) pour remplacer les données les moins récemment utilisées hors du cache lorsque l'espace du cache est plein. En langage Go, vous pouvez utiliser le package golang-lru pour implémenter le cache LRU. Voici un exemple d'implémentation :

package main

import (
    "fmt"
    "github.com/hashicorp/golang-lru"
)

func main() {
    cache, _ := lru.New(128)
    cache.Add("key1", "value1")
    cache.Add("key2", "value2")

    if res, ok := cache.Get("key1"); ok {
        fmt.Println(res)
    }
    cache.Remove("key2")
    fmt.Println(cache.Len())
}

Dans l'exemple de code ci-dessus, nous créons d'abord un cache LRU, ajoutons des données au cache en appelant la méthode Add, récupérons les données du cache à l'aide de la méthode Get et supprimons les données de le cache LRU à l'aide de la méthode Remove Supprimer les données.

Comment concevoir un système de mise en cache efficace

Pour différents scénarios et besoins, nous devons souvent choisir différentes stratégies de mise en cache. Cependant, quelle que soit la stratégie de mise en cache adoptée, nous devons réfléchir à la manière de concevoir un système de mise en cache efficace.

Voici quelques conseils pour concevoir un système de mise en cache efficace :

1. Définissez la bonne taille de cache

La taille du cache doit être définie en fonction des modèles d'accès à la mémoire et aux données du système. Si le cache est trop volumineux, la mémoire système sera limitée et les performances du système diminueront. Si le cache est trop petit, les ressources système ne pourront pas être pleinement utilisées et un cache suffisant ne pourra pas être fourni.

2. Définissez un délai d'expiration du cache approprié

Définir un délai d'expiration du cache approprié peut empêcher les données mises en cache d'être trop anciennes et garantir la nature en temps réel des données. Le délai d'expiration du cache doit être défini en fonction des caractéristiques des données et des modèles d'accès.

3. Utiliser un cache à plusieurs niveaux

Pour les données qui ne sont pas consultées fréquemment, vous pouvez utiliser un cache de stockage disque ou réseau plus grand ; et pour les données qui sont consultées plus fréquemment, vous pouvez utiliser un cache mémoire plus petit ; Grâce à la mise en cache à plusieurs niveaux, les performances et l'évolutivité du système peuvent être améliorées.

4. Pénétration du cache

La pénétration du cache signifie que les données demandées n'existent pas dans le cache et que les données demandées n'existent pas dans la source de données. Afin d'éviter la pénétration du cache, vous pouvez ajouter un indicateur booléen pour indiquer si les données existent à l'expiration du cache. Lorsque les données interrogées n'existent pas, des données vides sont renvoyées et le bit indicateur des données est défini sur faux. La requête suivante sera basée sur le bit indicateur pour éviter les requêtes répétées.

5. Avalanche de cache

L'avalanche de cache signifie qu'une grande quantité de données mises en cache échoue en même temps, provoquant l'envoi d'un grand nombre de requêtes sur le système back-end, provoquant un crash du système. Afin d'éviter le problème d'avalanche de cache, vous pouvez utiliser le caractère aléatoire du délai d'expiration du cache pour distribuer, ou diviser le délai d'expiration du cache en plusieurs périodes, et les délais d'expiration dans différentes périodes sont aléatoires pour éviter un grand nombre de cache pannes en même temps, provoquant une charge excessive du système.

Résumé

Dans le langage Go, l'utilisation du cache peut améliorer efficacement les performances du système et la vitesse de réponse. Nous pouvons choisir différentes solutions d'implémentation de cache, telles que map, sync.Map, LRU Cache, Redis, etc. Dans le même temps, lors de la conception d'un système de cache efficace, il est nécessaire de sélectionner une stratégie de cache appropriée en fonction de besoins et de scénarios spécifiques, et de prendre en compte des problèmes tels que la taille du cache, le délai d'expiration du cache, le cache multiniveau, la pénétration du cache, l'avalanche de cache. , etc.

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!