Golang高性能无GC泛型LRU哈希映射插件库go-freelru的使用

FreeLRU - 无GC、快速且通用的Go LRU哈希映射库

FreeLRU允许你在不引入GC开销的情况下缓存对象。它使用Go泛型来获得简单性、类型安全性和性能，而不是接口类型。在提供的Go基准测试中，它的性能优于其他LRU实现。API设计简单，便于从其他LRU实现迁移。

LRU: 单线程LRU哈希映射

LRU是一个单线程LRU哈希映射实现。它使用快速精确的LRU算法，没有锁开销。它专为低GC开销和类型安全而开发。对于线程安全，请选择SyncedLRU或ShardedLRU，或者自行处理锁。

SyncedLRU: 低并发环境的并发LRU哈希映射

SyncedLRU是围绕LRU包装的并发安全LRU哈希映射实现。它最适合锁竞争不是问题的低并发环境。它使用精确的LRU算法。

ShardedLRU: 高并发环境的并发LRU哈希映射

ShardedLRU是一个分片的、并发安全的LRU哈希映射实现。它最适合锁竞争严重的高并发环境。由于分片特性，它使用近似LRU算法。

示例用法

package main

import (
	"fmt"

	"github.com/cespare/xxhash/v2"

	"github.com/elastic/go-freelru"
)

// 更多哈希函数见 https://github.com/elastic/go-freelru/blob/main/bench/hash.go
func hashStringXXHASH(s string) uint32 {
	return uint32(xxhash.Sum64String(s))
}

func main() {
	// 创建一个容量为8192的LRU缓存，使用xxhash作为哈希函数
	lru, err := freelru.New[string, uint64](8192, hashStringXXHASH)
	if err != nil {
		panic(err)
	}

	key := "go-freelru"
	val := uint64(999)
	
	// 添加键值对
	lru.Add(key, val)

	// 获取值
	if v, ok := lru.Get(key); ok {
		fmt.Printf("found %v=%v\n", key, v)
	}

	// 输出:
	// found go-freelru=999
}

性能基准测试

添加对象性能

BenchmarkFreeLRUAdd_int_int-20                  43097347                27.41 ns/op            0 B/op          0 allocs/op
BenchmarkSimpleLRUAdd_int_int-20                12253708                93.85 ns/op           48 B/op          1 allocs/op
BenchmarkMapAdd_int_int-20                      35306983                46.29 ns/op            0 B/op          0 allocs/op

获取对象性能

BenchmarkFreeLRUGet-20                          83158561                13.80 ns/op            0 B/op          0 allocs/op
BenchmarkSimpleLRUGet-20                        146248706                8.199 ns/op           0 B/op          0 allocs/op
BenchmarkMapGet-20                              195464706                6.031 ns/op           0 B/op          0 allocs/op

哈希函数比较

整数哈希性能

BenchmarkHashInt_AESENC-20                      1000000000               0.9659 ns/op          0 B/op          0 allocs/op
BenchmarkHashInt_FNV1A-20                       621439513                1.919 ns/op           0 B/op          0 allocs/op
BenchmarkHashInt_XXH3HASH-20                    562645186                2.127 ns/op           0 B/op          0 allocs/op

字符串哈希性能

BenchmarkHashString_AESENC-20                   475896514                2.472 ns/op           0 B/op          0 allocs/op
BenchmarkHashString_XXH3HASH-20                 375255375                3.182 ns/op           0 B/op          0 allocs/op
BenchmarkHashString_FNV1A-20                    60162328                19.33 ns/op            0 B/op          0 allocs/op

高级用法示例

package main

import (
	"fmt"
	"hash/fnv"

	"github.com/elastic/go-freelru"
)

func hashInt(key int) uint32 {
	h := fnv.New32a()
	h.Write([]byte{byte(key), byte(key >> 8), byte(key >> 16), byte(key >> 24)})
	return h.Sum32()
}

func main() {
	// 创建容量为1024的LRU缓存，使用自定义哈希函数
	lru, err := freelru.New[int, string](1024, hashInt)
	if err != nil {
		panic(err)
	}

	// 设置内存超分配为100%以提高性能
	lru.SetOvercommit(1.0)

	// 添加多个键值对
	for i := 0; i < 1000; i++ {
		lru.Add(i, fmt.Sprintf("value-%d", i))
	}

	// 获取并打印值
	if v, ok := lru.Get(42); ok {
		fmt.Println("Value for key 42:", v)
	}

	// 获取当前缓存大小
	fmt.Println("Cache size:", lru.Len())

	// 清空缓存
	lru.Purge()
}

总结

go-freelru是一个高性能、无GC压力的LRU缓存实现，特别适合需要高性能缓存的Go应用程序。它通过以下方式优化性能：

1. 合并哈希映射和环形缓冲区到连续数组
2. 避免GC开销
3. 使用泛型实现类型安全和减少内存分配
4. 支持哈希表内存超分配

根据你的使用场景，可以选择单线程的LRU、低并发环境的SyncedLRU或高并发环境的ShardedLRU实现。