Go 本地缓存选型与 GC 调优：基于 Benchmark 的性能分析与实践

package main

import (
	"fmt"
	"runtime"
	"testing"
	"time"
)

// 包含指针的结构
type ItemPtr struct {
	data *string
}

// 模拟测试不同结构的 GC 扫描耗时
func BenchmarkGCWithPointer(b *testing.B) {
	const count = 5_000_000
	m := make(map[int]*ItemPtr, count)
	str := "benchmark_test_data"
	for i := 0; i < count; i++ {
		m[i] = &ItemPtr{data: &str}
	}

	runtime.GC()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		t0 := time.Now()
		runtime.GC()
		b.ReportMetric(float64(time.Since(t0).Microseconds()), "gc_us")
	}
}

func BenchmarkGCWithoutPointer(b *testing.B) {
	const count = 5_000_000
	// 完全没有指针
	m := make(map[uint64][24]byte, count)
	var val [24]byte
	for i := uint64(0); i < count; i++ {
		m[i] = val
	}

	runtime.GC()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		t0 := time.Now()
		runtime.GC()
		b.ReportMetric(float64(time.Since(t0).Microseconds()), "gc_us")
	}
}

goos: darwin
goarch: arm64
BenchmarkGCWithPointer-8       	       5	 184521000 ns/op	  184521 gc_us
BenchmarkGCWithoutPointer-8    	     100	  11234000 ns/op	   11234 gc_us

BenchmarkNativeMap_Set-8      1000000        1320 ns/op       216 B/op        3 allocs/op
BenchmarkBigCache_Set-8       5000000         290 ns/op        48 B/op        1 allocs/op

BenchmarkNativeMap_Get-8      3000000         410 ns/op         0 B/op        0 allocs/op
BenchmarkBigCache_Get-8       6000000         195 ns/op        24 B/op        1 allocs/op

package main

import (
	"context"
	"fmt"
	"time"

	"github.com/allegro/bigcache/v3"
)

type LocalCache struct {
	cache *bigcache.BigCache
}

func NewLocalCache(maxMemoryMB int) (*LocalCache, error) {
	// 配置 BigCache: 避开 GC 扫描的关键是正确配置 Shards 和内存上限
	config := bigcache.Config{
		Shards:             1024,             // 分片数，必须是 2 的幂次，降低分片锁竞争
		LifeWindow:         10 * time.Minute, // 过期时间
		CleanWindow:        1 * time.Minute,  // 清理周期
		MaxEntriesInWindow: 1000 * 10 * 60,   // 预估生命周期内的元素总量
		MaxEntrySize:       500,              // 预估单条 entry 大小(字节)
		HardMaxCacheSize:   maxMemoryMB,      // 内存硬限制 (MB)
		OnRemove:           nil,
	}

	bc, err := bigcache.New(context.Background(), config)
	if err != nil {
		return nil, err
	}
	return &LocalCache{cache: bc}, nil
}

func (c *LocalCache) Set(key string, val []byte) error {
	return c.cache.Set(key, val)
}

func (c *LocalCache) Get(key string) ([]byte, error) {
	return c.cache.Get(key)
}

func main() {
	c, err := NewLocalCache(512) // 512 MB 限制
	if err != nil {
		panic(err)
	}

	key := "user_token_12345"
	val := []byte("eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...")

	_ = c.Set(key, val)
	data, _ := c.Get(key)
	fmt.Printf("Get key: %s, val: %s\n", key, string(data))
}