Golang高性能线程安全内存缓存插件库fastcache的使用

简介

fastcache是一个快速线程安全的内存缓存库，专为存储大量条目而设计，避免了GC开销。它具有以下特点：

• 快速：性能在多核CPU上可扩展
• 线程安全：并发goroutine可以安全地读写单个缓存实例
• 自动淘汰：当达到最大缓存大小时自动淘汰旧条目
• 简单API：易于使用的接口
• 可持久化：可以将缓存保存到文件并从文件加载

安装

go get github.com/VictoriaMetrics/fastcache

基本使用示例

package main

import (
	"fmt"
	"github.com/VictoriaMetrics/fastcache"
)

func main() {
	// 创建一个最大100MB的缓存
	cache := fastcache.New(100 * 1024 * 1024)
	
	// 设置缓存值
	key := []byte("user:123")
	value := []byte("John Doe")
	cache.Set(key, value)
	
	// 获取缓存值
	var dst []byte
	dst = cache.Get(dst, key)
	fmt.Printf("Got value: %s\n", dst) // 输出: Got value: John Doe
	
	// 检查键是否存在
	if cache.Has(key) {
		fmt.Println("Key exists")
	}
	
	// 删除键
	cache.Del(key)
	
	// 获取不存在的键
	dst = cache.Get(dst, key)
	fmt.Printf("Got value for non-existent key: %v\n", dst) // 输出: Got value for non-existent key: []
	
	// 获取缓存统计信息
	var stats fastcache.Stats
	cache.UpdateStats(&stats)
	fmt.Printf("Cache stats: %+v\n", stats)
}

大条目缓存示例

对于超过64KB的大条目，需要使用特殊的API：

package main

import (
	"fmt"
	"github.com/VictoriaMetrics/fastcache"
)

func main() {
	cache := fastcache.New(100 * 1024 * 1024)
	
	// 设置大条目
	bigKey := []byte("big:data")
	bigValue := make([]byte, 128*1024) // 128KB数据
	for i := range bigValue {
		bigValue[i] = byte(i % 256)
	}
	
	// 使用SetBig存储大条目
	cache.SetBig(bigKey, bigValue)
	
	// 获取大条目
	retrievedValue := cache.GetBig(nil, bigKey)
	fmt.Printf("Retrieved big value length: %d\n", len(retrievedValue))
	
	// 验证数据
	valid := true
	for i := range retrievedValue {
		if retrievedValue[i] != byte(i % 256) {
			valid = false
			break
		}
	}
	fmt.Printf("Data integrity: %v\n", valid)
}

缓存持久化示例

package main

import (
	"fmt"
	"github.com/VictoriaMetrics/fastcache"
	"log"
	"os"
)

func main() {
	// 创建缓存
	cache := fastcache.New(100 * 1024 * 1024)
	
	// 设置一些值
	cache.Set([]byte("key1"), []byte("value1"))
	cache.Set([]byte("key2"), []byte("value2"))
	
	// 保存到文件
	tmpFile := "cache_data.tmp"
	err := cache.SaveToFile(tmpFile)
	if err != nil {
		log.Fatalf("Cannot save cache to file: %s", err)
	}
	
	// 从文件加载
	newCache := fastcache.New(100 * 1024 * 1024)
	err = fastcache.LoadFromFile(tmpFile, newCache)
	if err != nil {
		log.Fatalf("Cannot load cache from file: %s", err)
	}
	
	// 验证加载的数据
	value := newCache.Get(nil, []byte("key1"))
	fmt.Printf("Loaded value for key1: %s\n", value) // 输出: Loaded value for key1: value1
	
	// 清理临时文件
	_ = os.Remove(tmpFile)
}

性能对比

fastcache在性能上优于BigCache、标准Go map和sync.Map：

BenchmarkBigCacheSet-4      2000   10566656 ns/op   6.20 MB/s
BenchmarkBigCacheGet-4      2000    6902694 ns/op   9.49 MB/s
BenchmarkCacheSet-4         5000    3808874 ns/op  17.21 MB/s
BenchmarkCacheGet-4         5000    3293849 ns/op  19.90 MB/s
BenchmarkStdMapSet-4        2000   10559382 ns/op   6.21 MB/s
BenchmarkStdMapGet-4        5000    2687404 ns/op  24.39 MB/s
BenchmarkSyncMapSet-4        500   24703219 ns/op   2.65 MB/s
BenchmarkSyncMapGet-4       5000    2265892 ns/op  28.92 MB/s

限制

1. 键和值必须是字节切片，其他类型需要先序列化
2. 超过64KB的大条目需要使用特殊的API
3. 不支持缓存过期，条目只在缓存大小溢出时被淘汰

架构细节

fastcache采用了类似BigCache的设计理念：

• 缓存由多个桶组成，每个桶有自己的锁，适合多核CPU
• 每个桶包含一个哈希映射和64KB大小的字节切片块
• 块在可能的情况下分配在堆外，减少GC压力

总结

fastcache是一个高性能、线程安全的内存缓存解决方案，特别适合需要存储大量条目的场景。它通过减少GC开销和优化内存使用，提供了比标准map和其他缓存库更好的性能。