Guide du débutant : Comment implémenter la mise en cache dans Golang ?

Dans les langages de programmation modernes, la mise en cache est un outil largement utilisé pour améliorer les performances des applications et réduire le temps de réponse. Golang est un langage de programmation rapide et performant. Il prend naturellement en charge la technologie de mise en cache, car la mise en cache a également un impact important sur les performances des applications Golang.

Dans cet article, nous apprendrons comment implémenter la mise en cache dans Golang et comment utiliser la mise en cache pour améliorer les performances de votre application.

1. Qu'est-ce que le cache ?

La mise en cache est une technologie qui stocke les résultats de calculs ou les résultats de requêtes de base de données pour une utilisation future. La prochaine fois que le même résultat est demandé, le cache renvoie immédiatement le résultat précédemment récupéré sans avoir à recalculer ou interroger les données. Dans certains cas, la mise en cache peut améliorer considérablement les performances des applications et réduire les temps de réponse.

2. Mise en cache dans Golang

Dans Golang, nous pouvons utiliser la structure des données cartographiques pour implémenter la mise en cache. La structure de données Map fournit un mécanisme de stockage de paires clé-valeur, où chaque clé est associée à une valeur. Nous pouvons utiliser map pour stocker les résultats de calculs ou les résultats de requêtes, ainsi que leurs clés. Lorsque la même clé est demandée la prochaine fois, nous pouvons obtenir la valeur associée de la carte sans avoir à calculer ou à interroger à nouveau le résultat.

Voici un exemple d'utilisation de map pour implémenter la mise en cache :

package main

import (
    "fmt"
    "time"
)

// Cache stores previously computed results.
var Cache = map[string]interface{}{}

func ExampleCache() {
    // Check if the key is in the cache.
    value, ok := Cache["mykey"]
    if ok {
        fmt.Println("From Cache:", value)
        return
    }

    // Compute the result if it's not in the cache.
    time.Sleep(2 * time.Second)
    result := "Hello, World!"

    // Store the result in the cache.
    Cache["mykey"] = result

    fmt.Println("Computed Result:", result)
}

func main() {
    ExampleCache()
    ExampleCache()
}

Dans le code ci-dessus, nous avons créé une variable de carte nommée "Cache" qui stocke les paires clé-valeur. Lorsque la même clé sera demandée la prochaine fois, nous pourrons facilement récupérer la valeur de la carte "Cache".

Dans notre exemple, nous simulons le processus de calcul du résultat du calcul en utilisant l'instruction time.Sleep. Si la valeur est trouvée et renvoyée, « From Cache : » et la valeur correspondante seront imprimés ; sinon, « Compute Result : » et le résultat du calcul seront imprimés.

3. Utiliser la mise en cache avec délais d'attente

Dans le monde réel, les caches peuvent devenir obsolètes ou ne plus être nécessaires dans certaines situations. Par exemple, la valeur peut avoir été modifiée pour une raison quelconque, devenir obsolète ou ne plus être nécessaire.

Dans ce cas, nous pouvons utiliser un cache avec une fonction de délai d'attente, qui videra automatiquement le cache après une certaine période de temps. Ce type de mise en cache nous aide à garantir que nous utilisons les données les plus récentes et non des données obsolètes.

Voici un exemple d'implémentation de cache avec fonction timeout dans Golang :

package main

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

// ExpirationMap stores keys and expirations.
type ExpirationMap struct {
    sync.RWMutex
    data map[string]time.Time
}

// Expired returns true if key has expired.
func (m *ExpirationMap) Expired(key string) bool {
    m.RLock()
    defer m.RUnlock()

    // Get the key's expiration time.
    expiration, ok := m.data[key]
    if !ok {
        return true
    }

    // Check if the key has expired.
    return time.Until(expiration) < 0
}

// Set sets the key's expiration time.
func (m *ExpirationMap) Set(key string, duration time.Duration) {
    m.Lock()
    defer m.Unlock()

    // Set the key's expiration time.
    m.data[key] = time.Now().Add(duration)
}

// Delete removes the key from the map.
func (m *ExpirationMap) Delete(key string) {
    m.Lock()
    defer m.Unlock()

    // Delete the key from the map.
    delete(m.data, key)
}

// Cache stores previously computed results.
var Cache = map[string]interface{}{}

// Expiration stores expiration times for cache keys.
var Expiration = ExpirationMap{data: make(map[string]time.Time)}

func ExampleCacheWithExpiration() {
    // Check if the key is in the cache.
    value, ok := Cache["mykey"]
    if ok && !Expiration.Expired("mykey") {
        fmt.Println("From Cache:", value)
        return
    }

    // Compute the result if it's not in the cache.
    time.Sleep(2 * time.Second)
    result := "Hello, World!"

    // Store the result in the cache.
    Cache["mykey"] = result
    Expiration.Set("mykey", 5*time.Second)

    fmt.Println("Computed Result:", result)
}

func main() {
    ExampleCacheWithExpiration()
    ExampleCacheWithExpiration()

    // Wait for the expiration time to elapse.
    time.Sleep(6 * time.Second)

    ExampleCacheWithExpiration()
}

Dans le code ci-dessus, nous utilisons une structure appelée "ExpirationMap", qui stocke la clé et l'heure d'expiration. Nous utilisons une carte "Expiration" pour enregistrer l'heure d'expiration de chaque clé dans le cache. Si la clé expire, nous devons alors recalculer le résultat.

Dans notre exemple, lorsque nous appelons la fonction "ExampleCacheWithExpiration" la première et la deuxième fois, la valeur de la clé "mykey" sera calculée et stockée dans notre cache avec un délai d'expiration de 5 secondes. Au deuxième appel à la fonction, nous obtiendrons la valeur de la clé "mykey" du cache car la clé n'a pas encore expiré.

Au troisième appel à la fonction nous attendrons plus de 5 secondes que la clé "mykey" expire. Lorsque la clé expire, nous forçons un recalcul des résultats afin de pouvoir utiliser les dernières données.

4. Résumé

La méthode pour implémenter la mise en cache dans Golang est très simple. Nous pouvons utiliser la structure des données cartographiques pour stocker les paires clé-valeur et leurs résultats. Nous pouvons également utiliser la mise en cache avec des délais d'attente pour garantir que nous utilisons les données les plus récentes et non des données obsolètes.

Bien que la mise en cache puisse améliorer considérablement les performances des applications, nous devons également prêter attention à l'utilisation du cache. Lors de l'utilisation du cache, nous devons garantir la cohérence du cache et ajuster la taille du cache si nécessaire. Les véritables avantages de la mise en cache ne peuvent être obtenus que s’ils sont utilisés correctement.

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!