Guide du débutant : analyse complète de la technologie de mise en cache dans Golang.-Golang-php.cn

Golang est un langage de programmation très populaire ces dernières années. Il est apprécié pour ses puissantes performances de concurrence et sa syntaxe concise. Dans Golang, la technologie de mise en cache est un élément très important. La mise en cache peut nous aider à réduire le temps de réponse et à améliorer les performances du système. Cet article fournira une analyse complète de la technologie de mise en cache dans Golang pour aider les débutants à mieux comprendre et appliquer la technologie de mise en cache.

1. Qu'est-ce que le cache ?

Le cache est une méthode de stockage de données auxiliaire utilisée pour accélérer l'accès aux données et améliorer les performances du système. L'essence de la mise en cache est d'équilibrer la vitesse d'accès et l'espace de stockage. Certaines données couramment utilisées peuvent être stockées dans le cache pour accélérer l'accès. Dans les applications Web, la vitesse de calcul du serveur est généralement bien plus rapide que la vitesse de lecture du disque dur. Le stockage des données en mémoire peut grandement améliorer la vitesse de réponse.

2. Mise en cache dans Golang

Dans Golang, il existe deux méthodes de mise en cache courantes : le cache mémoire et le cache distribué. Chacun sera présenté en détail ci-dessous.

Cache mémoire

Le cache mémoire stocke les données dans la mémoire de l'ordinateur pour accélérer l'accès aux données. Dans Golang, la mise en cache de la mémoire est généralement implémentée à l'aide d'une carte ou d'une tranche.

Utilisez map pour implémenter la mise en cache mémoire :

package main

import (
    "fmt"
    "time"
)

func main() {
    cache := make(map[string]string)
    cache["key1"] = "value1"
    cache["key2"] = "value2"
    
    // 读缓存
    cacheValue, ok := cache["key1"]
    if ok {
        fmt.Println("cache hit:", cacheValue)
    } else {
        fmt.Println("cache miss")
    }
    
    // 延迟1秒后写入新的缓存
    time.Sleep(1 * time.Second)
    cache["key3"] = "value3"
}

Copier après la connexion

Dans le code ci-dessus, nous utilisons la fonction make pour créer une variable de type map de type chaîne cache et l'y ajouter Il existe deux paires clé-valeur. Lors de la lecture du cache, nous obtenons d'abord si la valeur du cache existe via la variable ok, et si elle existe, imprimons le contenu du cache. Enfin, après avoir simulé un délai d'une seconde via la fonction time.Sleep, nous avons ajouté une nouvelle paire clé-valeur au cache. make函数创建了一个字符串类型的map类型的变量cache，并向其中添加了两个键值对。在读取缓存时，我们首先通过ok变量获取缓存值是否存在，如果存在则打印出缓存内容。最后，我们通过time.Sleep函数模拟了1秒钟的延时后，向缓存中新增了一个键值对。

使用slice实现内存缓存：

package main

import (
    "fmt"
    "time"
)

type CacheItem struct {
    Key string
    Value string
}

func main() {
    cache := []CacheItem{
        {Key: "key1", Value: "value1"},
        {Key: "key2", Value: "value2"},
    }
    
    // 读缓存
    cacheValue, ok := findCacheItemByKey(cache, "key1")
    if ok {
        fmt.Println("cache hit:", cacheValue.Value)
    } else {
        fmt.Println("cache miss")
    }
    
    // 延迟1秒后写入新的缓存
    time.Sleep(1 * time.Second)
    cache = append(cache, CacheItem{Key: "key3", Value: "value3"})
}

func findCacheItemByKey(cache []CacheItem, key string) (CacheItem, bool) {
    for _, item := range cache {
        if item.Key == key {
            return item, true
        }
    }
    return CacheItem{}, false
}

Copier après la connexion

上述代码中，我们创建了一个CacheItem结构体来表示缓存中的每个元素，然后使用slice来存储多个CacheItem结构体。在读取缓存时，我们调用了findCacheItemByKey函数来查找缓存中的元素。最后，我们通过time.Sleep函数模拟了1秒钟的延时后，向缓存中新增了一个CacheItem元素。

在内存缓存中，我们需要注意缓存的容量和缓存过期时间。如果缓存容量过小，很容易造成缓存失效，增加访问数据库的次数。如果缓存过期时间设置不当，也会导致缓存的命中率下降，进而影响系统性能。

分布式缓存

分布式缓存是将数据存储在多台计算机的内存中，以加速数据读取速度。在Golang中，常见的分布式缓存有Memcached和Redis。

使用Memcached作为分布式缓存：

package main

import (
    "fmt"
    "time"

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

func main() {
    mc := memcache.New("127.0.0.1:11211")
    mc.Set(&memcache.Item{Key: "key1", Value: []byte("value1")})
    mc.Set(&memcache.Item{Key: "key2", Value: []byte("value2")})

    // 读缓存
    cacheValue, err := mc.Get("key1")
    if err == nil {
        fmt.Println("cache hit:", string(cacheValue.Value))
    } else {
        fmt.Println("cache miss")
    }

    // 延迟1秒后写入新的缓存
    time.Sleep(1 * time.Second)
    mc.Set(&memcache.Item{Key: "key3", Value: []byte("value3")})
}

Copier après la connexion

上述代码中，我们首先通过gomemcache/memcache包实例化了一个Memcached客户端，并向其中添加了两个键值对。在读取缓存时，我们调用了Get函数来获取缓存值。最后，我们通过time.Sleep函数模拟了1秒钟的延时后，向缓存中新增了一个键值对。

使用Redis作为分布式缓存：

package main

import (
    "fmt"
    "time"

    "github.com/go-redis/redis"
)

func main() {
    rdb := redis.NewClient(&redis.Options{
        Addr:     "localhost:6379",
        Password: "",
        DB:       0,
    })
    defer rdb.Close()

    rdb.Set("key1", "value1", 0)
    rdb.Set("key2", "value2", 0)

    // 读缓存
    cacheValue, err := rdb.Get("key1").Result()
    if err == nil {
        fmt.Println("cache hit:", cacheValue)
    } else {
        fmt.Println("cache miss")
    }

    // 延迟1秒后写入新的缓存
    time.Sleep(1 * time.Second)
    rdb.Set("key3", "value3", 0)
}

Copier après la connexion

上述代码中，我们首先通过go-redis/redis包实例化了一个Redis客户端，并向其中添加了两个键值对。在读取缓存时，我们调用了Get函数来获取缓存值。最后，我们通过time.Sleep

Utilisez slice pour implémenter la mise en cache mémoire :

rrreee

Dans le code ci-dessus, nous créons une structure CacheItem pour représenter chaque élément du cache, puis utilisons slice pour stocker plusieurs CacheItem code>structure. Lors de la lecture du cache, nous appelons la fonction findCacheItemByKey pour retrouver l'élément dans le cache. Enfin, après avoir simulé un délai d'une seconde via la fonction time.Sleep, nous avons ajouté un nouvel élément CacheItem au cache.

Dans le cache mémoire, nous devons faire attention à la capacité du cache et au délai d'expiration du cache. Si la capacité du cache est trop petite, cela entraînera facilement une défaillance du cache et augmentera le nombre d'accès à la base de données. Si le délai d'expiration du cache est mal défini, le taux de réussite du cache diminuera également, affectant ainsi les performances du système.

Cache distribué
Le cache distribué stocke les données dans la mémoire de plusieurs ordinateurs pour accélérer la lecture des données. Dans Golang, les caches distribués courants incluent Memcached et Redis.
Utilisez Memcached comme cache distribué :
rrreee

gomemcache/memcache

Get

time.Sleep

Utilisez Redis comme cache distribué :

Dans le code ci-dessus, nous instancions d'abord un client Redis via le package go-redis/redis et y ajoutons deux paires clé-valeur . Lors de la lecture du cache, nous appelons la fonction Get pour obtenir la valeur du cache. Enfin, après avoir simulé un délai d'une seconde via la fonction time.Sleep, nous avons ajouté une nouvelle paire clé-valeur au cache.

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!