Comment utiliser Golang et Memcache pour implémenter la mise en cache à haute concurrence.

Avec le développement rapide des applications Web, la simultanéité élevée est devenue un problème de plus en plus courant. La mise en cache est une technologie essentielle permettant aux développeurs de maintenir les performances et la réactivité des applications. Dans cet article, nous expliquerons comment utiliser Golang et Memcache pour implémenter la mise en cache à haute concurrence.

Qu'est-ce que memcache ?

Memcache est un système de cache de mémoire distribué hautes performances, souvent utilisé pour mettre en cache des données dans des applications Web, telles que les résultats de requêtes de base de données, les réponses d'API externes, etc. En raison de ses hautes performances et de son évolutivité, Memcache est largement utilisé dans les applications Web impliquant un grand nombre d'opérations de lecture.

Principe de fonctionnement de Memcache

Memcache fonctionne principalement en mémoire et son espace de cache est alloué par plusieurs machines. Il est généralement utilisé pour mettre en cache diverses données, telles que les résultats des requêtes de base de données et. Réponses de l'API attendez. Chaque entrée de cache se compose d'une clé et d'une valeur, la clé identifiant les données et la valeur pouvant être de n'importe quel type de données.

Lorsqu'une application a besoin de lire des données, elle demandera d'abord les données au serveur Memcache. Si le serveur a mis les données en cache, il renvoie immédiatement les données à l'application. Si le serveur ne met pas les données en cache, l'application interrogera les données de la base de données ou d'une autre source et les stockera dans Memcache pour une utilisation ultérieure. De cette façon, toutes les requêtes ultérieures peuvent obtenir les données directement du cache sans avoir à les interroger à nouveau depuis la base de données ou d'autres sources.

Utiliser Golang et Memcache

Utiliser Memcache dans Golang est très simple. Vous pouvez utiliser la bibliothèque memcache pour vous connecter directement au serveur memcache et utiliser une API simple pour les opérations de lecture et d'écriture. Voici un exemple utilisant Golang et memcache :

package main

import (
    "log"
    "net"
    "time"

    "github.com/bradfitz/gomemcache/memcache"
)

func main() {
    // 连接到memcache服务器
    mc := memcache.New("localhost:11211")

    // 在缓存中设置值
    err := mc.Set(&memcache.Item{Key: "mykey", Value: []byte("myvalue"), Expiration: 60})
    if err != nil {
        log.Fatalf("Error setting value: %v", err)
    }

    // 从缓存中获取值
    item, err := mc.Get("mykey")
    if err == memcache.ErrCacheMiss {
        log.Printf("Key not found in cache")
    } else if err != nil {
        log.Fatalf("Error getting value: %v", err)
    } else {
        log.Printf("Value: %s", item.Value)
    }

    // 在缓存中删除值
    err = mc.Delete("mykey")
    if err != nil {
        log.Fatalf("Error deleting value: %v", err)
    }
}

L'exemple de code se connecte d'abord au serveur memcache, puis stocke la clé "mykey" et la valeur "myvalue" dans le cache et stocke le réglage de l'heure. 60 secondes. Ensuite, il récupère la valeur du cache et l'imprime. Enfin, il supprime la valeur du cache.

Utiliser Golang et Memcache pour obtenir une mise en cache à haute concurrence

Afin d'obtenir une mise en cache à haute concurrence, nous pouvons utiliser la fonction goroutine de Golang et CAS (Comparer et échanger) de memcache. CAS est une opération atomique qui permet les mises à jour du cache sans provoquer de conditions de concurrence.

Dans l'exemple de code suivant, nous utilisons goroutine et CAS pour obtenir des mises à jour de cache hautes performances :

package main

import (
    "log"
    "net"
    "sync"
    "time"

    "github.com/bradfitz/gomemcache/memcache"
)

func main() {
    // 连接到memcache服务器
    mc := memcache.New("localhost:11211")

    // 初始化缓存
    err := initCache(mc)
    if err != nil {
        log.Fatalf("Error initializing cache: %v", err)
    }

    var wg sync.WaitGroup

    // 并发查询
    for i := 0; i < 100; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            log.Printf("Fetching key %d", i)
            item, err := mc.Get("mykey")
            if err == memcache.ErrCacheMiss {
                log.Printf("Key not found in cache")
            } else if err != nil {
                log.Fatalf("Error getting value: %v", err)
            } else {
                log.Printf("Value: %s", item.Value)
            }
        }(i)
    }

    // 等待所有的查询结束
    wg.Wait()

    log.Printf("Done")
}

func initCache(mc *memcache.Client) error {
    // 为每个键值对设置一个版本号
    const key = "mykey"
    const maxVersion = 10
    for i := 0; i < maxVersion; i++ {
        item := &memcache.Item{
            Key:        key,
            Value:      []byte("myvalue"),
            Expiration: 60,
            Flags:      uint32(i), // 版本号
        }
        if err := mc.Set(item); err != nil {
            return err
        }
    }

    // 设置缓存版本号
    item := &memcache.Item{
        Key:        key,
        Value:      []byte("myvalue"),
        Expiration: 0,
        Flags:      uint32(maxVersion),
    }
    return mc.Set(item)
}

L'exemple de code se connecte d'abord au serveur Memcache et initialise le cache, as Chaque paire clé-valeur est définie avec un numéro de version. Par la suite, il utilise une goroutine pour récupérer simultanément chaque paire clé-valeur du cache. Avant d'obtenir chaque valeur, il obtient d'abord le numéro de version actuel et le stocke dans une variable. Il récupère ensuite la valeur du cache et vérifie si le numéro de version est le même qu'avant de le récupérer. S'ils sont identiques, cela signifie que le cache n'a pas expiré et que la valeur peut être utilisée directement. Sinon, il récupérera la valeur de la base de données ou d'une autre source et la stockera dans le cache. De cette manière, même si plusieurs requêtes interrogent la même paire clé-valeur en même temps, il est garanti qu'une seule requête obtiendra la valeur de l'extérieur, tandis que les autres requêtes obtiendront la valeur directement du cache pour améliorer les performances.

Conclusion

Dans cet article, nous avons présenté comment utiliser Golang et Memcache pour implémenter la mise en cache à haute concurrence. Nous vous avons également montré comment utiliser les fonctionnalités CAS des goroutines et de memcache pour obtenir des mises à jour de cache hautes performances. Si vous écrivez une application Web hautement concurrente, l'utilisation de Memcache est un moyen efficace d'améliorer les performances de l'application. Memcache est indispensable lors de l'écriture d'applications Web 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!