Maison > Article > développement back-end > Guide du débutant : analyse complète de la technologie de mise en cache dans Golang.
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.
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" }
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 }
上述代码中,我们创建了一个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")}) }
上述代码中,我们首先通过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) }
上述代码中,我们首先通过go-redis/redis
包实例化了一个Redis客户端,并向其中添加了两个键值对。在读取缓存时,我们调用了Get
函数来获取缓存值。最后,我们通过time.Sleep
rrreee
Dans le code ci-dessus, nous créons une structureCacheItem
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. gomemcache/memcache
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. Utilisez Redis comme cache distribué :
rrreeeDans 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!