Go语言中嵌入式缓存库的用法详解_Golang

在 go 中，嵌入式缓存（in-memory cache）是提高应用程序性能的常见方案。

一个好的缓存库能够提供高效的存储机制、支持高并发访问并保证线程安全。go 语言中有一些非常高效的嵌入式缓存库，其中 groupcache 和 bigcache 是两个非常流行且高性能的库。

1. groupcache：高性能缓存库

groupcache 是由 google 开发的一个高性能缓存库，专为缓存服务中的数据访问而设计，具有良好的扩展性，并且内建了一些高效的并发控制和缓存失效策略。groupcache 在许多大规模分布式系统中被使用。

安装 groupcache

go get github.com/golang/groupcache

基本使用示例

下面是一个使用 groupcache 实现本地缓存的简单例子。groupcache 会将数据分组存储，并可以通过 getter 函数来加载数据。

package main

import (
	"fmt"
	"log"
	"github.com/golang/groupcache"
)

// 获取数据的函数，模拟从数据库或远程服务获取数据
func loaddata(ctx groupcache.context, key string, dest groupcache.sink) error {
	data := "value_for_" + key
	dest.setstring(data)
	return nil
}

func main() {
	// 创建一个 groupcache 缓存池
	// size 参数设置了缓存的大小，groupcache 会根据此参数自动管理缓存大小
	cache := groupcache.newgroup("examplecache", 64<<20, groupcache.getterfunc(loaddata))

	// 创建一个上下文并获取缓存中的数据
	var data string
	err := cache.get(nil, "some_key", groupcache.stringsink(&data))
	if err != nil {
		log.fatal(err)
	}

	// 输出缓存的数据
	fmt.println(data)
}

关键点：

groupcache 使用 group 来管理一组缓存数据，每个缓存的访问会通过 getter 函数动态加载。

缓存数据的加载会通过 getter 来实现，可以从外部数据源（如数据库或 api）加载数据。

支持并发安全，多个请求可以并发访问缓存并从源中加载数据。

2. bigcache：高效的内存缓存库

bigcache 是一个针对 go 的高性能缓存库，它设计的重点是优化并发访问性能，适合高并发场景下的数据缓存。与 groupcache 相比，bigcache 更加专注于内存优化和并发安全，并且支持大数据量的缓存。

安装 bigcache

go get github.com/allegro/bigcache/v3

基本使用示例

bigcache 适用于需要存储大量短生命周期的数据的场景，例如 web 应用中的会话缓存、api 缓存等。

package main

import (
	"fmt"
	"log"
	"github.com/allegro/bigcache/v3"
	"time"
)

func main() {
	// 创建一个 bigcache 实例，设置缓存的最大大小和过期时间
	cache, err := bigcache.newbigcache(bigcache.defaultconfig(10 * time.minute))
	if err != nil {
		log.fatal(err)
	}

	// 将数据存入缓存，key 为 "user_123"，value 为 "john doe"
	cache.set("user_123", []byte("john doe"))

	// 从缓存中获取数据
	entry, err := cache.get("user_123")
	if err != nil {
		log.fatal(err)
	}

	// 输出缓存的数据
	fmt.println("cache entry:", string(entry))
}

关键点：

bigcache 可以设置缓存的过期时间，支持自动清理过期缓存。

支持并发安全，多个 goroutine 可以并发读写缓存。

对内存的使用进行了优化，尤其适合存储大规模缓存数据。

3. golang-lru：最简单的 lru 缓存

lru（least recently used，最近最少使用）缓存是一种基于访问时间的缓存淘汰策略。golang-lru 库可以用于实现基于内存的 lru 缓存。适合用于数据访问量大的情况下进行缓存，超出缓存大小后，系统会自动淘汰最少使用的数据。

安装 golang-lru

go get github.com/golang/groupcache/lru

基本使用示例

package main

import (
	"fmt"
	"github.com/golang/groupcache/lru"
)

func main() {
	// 创建一个容量为 3 的 lru 缓存
	cache := lru.new(3)

	// 设置缓存
	cache.add("a", 1)
	cache.add("b", 2)
	cache.add("c", 3)

	// 打印缓存内容
	fmt.println("cache after adding 3 elements:", cache)

	// 添加新的元素，超出缓存容量，最旧的元素会被移除
	cache.add("d", 4)
	fmt.println("cache after adding 4th element (eviction occurs):", cache)

	// 检查是否存在某个元素
	if val, ok := cache.get("b"); ok {
		fmt.println("found 'b':", val)
	} else {
		fmt.println("'b' not found")
	}
}

关键点：

golang-lru 使用 lru 策略管理缓存。

数据量超出缓存时，会自动移除最少使用的数据。

适用于需要缓存一定数量的热数据的场景。