Golang a-t-il un cache ?

Golang est un langage de programmation open source qui prend en charge la programmation simultanée et parallèle et est excellent dans la gestion de requêtes simultanées élevées. Tout comme les autres langages de programmation, Golang dispose également de son propre mécanisme de mise en cache pour améliorer les performances du programme et la vitesse de réponse. Alors, Golang a-t-il du cache ? Cet article répondra à cette question pour vous.

Le langage Golang lui-même n'a fondamentalement aucun mécanisme de mise en cache intégré, mais il fournit des structures de données efficaces pour implémenter la mise en cache. Parmi eux, les plus couramment utilisés sont la carte intégrée (dictionnaire) et le verrou du package Sync.

La carte intégrée est l'une des structures de données les plus couramment utilisées dans le langage Golang. Elle fournit un mappage de paires clé-valeur. Nous pouvons utiliser Map pour implémenter un mécanisme de mise en cache simple. Par exemple, nous pouvons mettre en cache des données dans une carte, puis les récupérer en cas de besoin. S'il n'y a pas de données dans le cache, nous récupérons les données de la base de données ou de l'API et stockons le résultat dans le cache.

Voici un exemple simple qui montre comment utiliser Map pour stocker et récupérer des données mises en cache :

package main

import (
    "fmt"
    "time"
)

func main() {
    cache := make(map[string]string)
    //添加缓存项
    cache["key1"] = "value1"
    cache["key2"] = "value2"
    fmt.Println("Cache:", cache)

    //检索缓存
    value, found := cache["key1"]
    if found {
        fmt.Println("Value:", value)
    }

    //等待一段时间，模拟缓存过期
    time.Sleep(time.Second * 5)

    //检测缓存是否过期
    _, found = cache["key1"]
    if !found {
        fmt.Println("Cache expired")
    }
}

Dans l'exemple ci-dessus, nous avons utilisé la structure de données Map intégrée pour stocker les données mises en cache. Nous pouvons ajouter ou mettre à jour les valeurs mises en cache à l'aide de la syntaxe clé-valeur standard. Lorsque nous devons récupérer des données du cache, nous pouvons le faire en utilisant la même syntaxe clé-valeur. Cette méthode est très simple, mais elle n’implémente pas la fonctionnalité d’expiration du cache. Afin d'implémenter l'expiration du cache, nous devons utiliser un horodatage ou définir une minuterie pour distinguer la période de validité des données mises en cache.

En plus de la structure de données Map intégrée, Golang fournit également le package Sync, qui contient quelques primitives pour la programmation simultanée. Ces primitives incluent des verrous mutex, des verrous en lecture-écriture et des variables de condition. Grâce à ces primitives, nous pouvons implémenter un mécanisme de mise en cache simultané efficace.

Ce qui suit est un exemple de mise en cache simultanée utilisant un verrou mutex :

package main

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

//定义一个缓存结构体
type Cache struct {
    sync.Mutex
    data map[string]string
    expire map[string]int64
}

//添加缓存项
func (c *Cache) Set(key, value string, expire time.Duration) {
    c.Lock()
    defer c.Unlock()
    c.data[key] = value
    c.expire[key] = time.Now().Add(expire).UnixNano()
}

//检索缓存项
func (c *Cache) Get(key string) (string, bool) {
    c.Lock()
    defer c.Unlock()
    if expired, found := c.expire[key]; found {
        if time.Now().UnixNano() > expired {
            //缓存过期
            delete(c.data, key)
            delete(c.expire, key)
            return "", false
        }
    }
    value, found := c.data[key]
    return value, found
}

func main() {
    //初始化缓存结构体
    cache := Cache{
        data: make(map[string]string),
        expire: make(map[string]int64),
    }

    //添加缓存项
    cache.Set("key1", "value1", time.Second * 3)

    //检索缓存项
    value, found := cache.Get("key1")
    if found {
        fmt.Println("Value:", value)
    }

    //等待一段时间，模拟缓存过期
    time.Sleep(time.Second * 5)

    //检测缓存是否过期
    _, found = cache.Get("key1")
    if !found {
        fmt.Println("Cache expired")
    }
}

Dans l'exemple ci-dessus, nous utilisons un verrou mutex pour protéger les opérations de lecture et d'écriture des données mises en cache en définissant la limite de temps de l'élément de cache sur la valeur actuelle. time Comparez pour déterminer si l'élément de cache a expiré, afin de nettoyer le cache lorsqu'il expire.

En bref, le langage Golang n'a pas de mécanisme de mise en cache intégré, mais nous pouvons utiliser la structure de données Map qu'il fournit, les primitives de verrouillage du package Sync et d'autres moyens efficaces d'implémenter le mécanisme de mise en cache pour améliorer les performances du programme et vitesse de réponse.

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!