Go内存缓存

基本上每个项目都有加快服务响应或复杂计算的需求。简单快速的解决方案是使用缓存。通常，有Redis或Memcached，但我们在单实例微服务中不需要使用它们。有时候在你的Go应用程序中使用一个简单的内存缓存会更好，今天我想介绍实现内存缓存的方法。

Map

第一种方法是简单的缓存实现。通常，使用map存储结构体。此外，还需要监控元素的过期时间和缓存大小。

package go_cache

import (
    "errors"
    "sync"
    "time"
)
//这里缓存的对象是user结构体，包含id、email两个字段
type user struct {
    Id    int64  `json:"id"`
    Email string `json:"email"`
}
//实际存到map中的结构体内容
type cachedUser struct {
    user
    expireAtTimestamp int64
}
//创建缓存结构体，包含对象的增加、删除等方法
type localCache struct {
    stop chan struct{}

    wg    sync.WaitGroup
    mu    sync.RWMutex   //读写锁
    users map[int64]cachedUser  //map存储用户信息
}

//创建缓存对象，cleanupInterval设置定期清除缓存过期元素
func newLocalCache(cleanupInterval time.Duration) *localCache {
    lc := &localCache{
        users: make(map[int64]cachedUser),
        stop:  make(chan struct{}),
    }
    //启动goroutine后台定期清除过期元素
    lc.wg.Add(1)
    go func(cleanupInterval time.Duration) {
        defer lc.wg.Done()
        lc.cleanupLoop(cleanupInterval)
    }(cleanupInterval)

    return lc
}

func (lc *localCache) cleanupLoop(interval time.Duration) {
    t := time.NewTicker(interval)
    defer t.Stop()

    for {
        select {
        case <-lc.stop:  //主动退出
            return
        case <-t.C:
            lc.mu.Lock()
            for uid, cu := range lc.users {
                if cu.expireAtTimestamp <= time.Now().Unix() {
                    delete(lc.users, uid)
                }
            }
            lc.mu.Unlock()
        }
    }
}

func (lc *localCache) stopCleanup() {
    close(lc.stop)
    lc.wg.Wait()
}
//更新元素过期时间
func (lc *localCache) update(u user, expireAtTimestamp int64) {
    lc.mu.Lock()
    defer lc.mu.Unlock()

    lc.users[u.Id] = cachedUser{
        user:              u,
        expireAtTimestamp: expireAtTimestamp,
    }
}

var (
    errUserNotInCache = errors.New("the user isn't in cache")
)
//读缓存
func (lc *localCache) read(id int64) (user, error) {
    lc.mu.RLock()
    defer lc.mu.RUnlock()

    cu, ok := lc.users[id]
    if !ok {
        return user{}, errUserNotInCache
    }

    return cu.user, nil
}
//删除缓存元素
func (lc *localCache) delete(id int64) {
    lc.mu.Lock()
    defer lc.mu.Unlock()

    delete(lc.users, id)
}

上面的例子我们使用用户ID作为缓存元素的Key。使用map，所有update/read/delete操作时间复杂度都是O(1)

优点

• 实现简单
• 性能高

缺点

• 存储每一类结构体都需要实现缓存
• 需要单独测试缓存
• 单独的bug修复

gCache库

gCache库对缓存实现进行抽象，包含各种配置。例如，可以很简单地设置缓存淘汰规则，缓存元素最大长度，过期时间TTL等。

package go_cache

import (
    "errors"
    "fmt"
    "github.com/bluele/gcache"
    "time"
)

type gCache struct {
    users gcache.Cache //该对象可以缓存任何类型数据
}

const (
    cacheSize = 1_000_000
    cacheTTL  = 1 * time.Hour // default expiration
)

//创建缓存对象，使用ARC算法淘汰缓存元素
func newGCache() *gCache {
    return &gCache{
        users: gcache.New(cacheSize).Expiration(cacheTTL).ARC().Build(),
    }
}

//更新缓存元素过期时间
func (gc *gCache) update(u user, expireIn time.Duration) error {
    return gc.users.SetWithExpire(u.Id, u, expireIn)
}

//读取缓存
func (gc *gCache) read(id int64) (user, error) {
    val, err := gc.users.Get(id)
    if err != nil {
        if errors.Is(err, gcache.KeyNotFoundError) {
            return user{}, errUserNotInCache
        }

        return user{}, fmt.Errorf("get: %w", err)
    }

    return val.(user), nil
}

//删除缓存元素
func (gc *gCache) delete(id int64) {
    gc.users.Remove(id)
}

优点

• 可直接投入生产环境中使用
• 接口适用任意类型
• 不同的缓存淘汰算法：LRU，LFU，ARC

缺点

• 去缓存都需要做类型转换性能差
• 这个库有一点时间没有维护

BigCache库

BigCache库高性能、支持并发、缓存淘汰，可存储大量元素而不影响性能。BigCache将元素放在堆中忽略GC。

package go_cache

import (
    "encoding/json"
    "errors"
    "fmt"
    "github.com/allegro/bigcache"
    "strconv"
    "time"
)

type bigCache struct {
    users *bigcache.BigCache
}

func newBigCache() (*bigCache, error) {
    bCache, err := bigcache.NewBigCache(bigcache.Config{
        // 分片数量 (必须是2的幂次方)
        Shards: 1024,

        // 存活时间，过了该时间才会删除元素
        LifeWindow: 1 * time.Hour,

        //删除过期元素的时间间隔(清理缓存).
        // 如果设置为<= 0，则不执行任何操作
        // 设置为< 1秒会适得其反— bigcache只能精确到1秒.
        CleanWindow: 5 * time.Minute,

        // rps * lifeWindow, 仅用于初始内存分配
        MaxEntriesInWindow: 1000 * 10 * 60,

        // 以字节为单位的元素大小最大值，仅在初始内存分配时使用
        MaxEntrySize: 500,

        // 打印内存分配信息
        Verbose: false,

        // 缓存分配的内存不会超过这个限制, MB单位
        // 如果达到值，则可以为新条目覆盖最旧的元素
        // 0值表示没有限制
        HardMaxCacheSize: 256,

        // 当最旧的元素由于过期时间或没有剩余空间而被删除时，触发回调
        // 对于新元素，或者因为调用了delete。将返回一个表示原因的位掩码.
        // 默认值为nil，这意味着没有回调.
        OnRemove: nil,

        // OnRemoveWithReason当因为过期时间或没有空间时，最老一条元素被删除会触发该回调。会返回删除原因。
        // 默认值为nil。
        OnRemoveWithReason: nil,
    })
    if err != nil {
        return nil, fmt.Errorf("new big cache: %w", err)
    }

    return &bigCache{
        users: bCache,
    }, nil
}

func (bc *bigCache) update(u user) error {
    bs, err := json.Marshal(&u)
    if err != nil {
        return fmt.Errorf("marshal: %w", err)
    }

    return bc.users.Set(userKey(u.Id), bs)
}

func userKey(id int64) string {
    return strconv.FormatInt(id, 10)
}

func (bc *bigCache) read(id int64) (user, error) {
    bs, err := bc.users.Get(userKey(id))
    if err != nil {
        if errors.Is(err, bigcache.ErrEntryNotFound) {
            return user{}, errUserNotInCache
        }

        return user{}, fmt.Errorf("get: %w", err)
    }

    var u user
    err = json.Unmarshal(bs, &u)
    if err != nil {
        return user{}, fmt.Errorf("unmarshal: %w", err)
    }

    return u, nil
}

func (bc *bigCache) delete(id int64) {
    bc.users.Delete(userKey(id))
}

我们使用JSON编码/解码元素，但也可以使用任何数据格式。例如，一种二进制格式Protobuf可以显著提高性能。

优点

• 可用户生产环境
• 丰富的缓存配置
• 维护当中
• 缓存不会触发GC，在大元素存储性能高

缺点

• 需要自己实现元素编解码。

性能测试

goos: darwin
goarch: amd64
pkg: go-cache
cpu: Intel(R) Core(TM) i5-8257U CPU @ 1.40GHz
Benchmark_bigCache
Benchmark_bigCache-8         1751281           688.0 ns/op       390 B/op          6 allocs/op
Benchmark_gCache
Benchmark_gCache-8            772846          1699 ns/op         373 B/op          8 allocs/op
Benchmark_localCache
Benchmark_localCache-8       1534795           756.6 ns/op       135 B/op          0 allocs/op
PASS
ok      go-cache    6.044s

BigCache是最快的缓存库。gCache的性能主要受到interface{}对象转换上。

总结

我们调研了Golang的不同内存缓存。记住没有最好的解决方案，需要根据实际应用场景来决定。 使用本文来比较解决方案，并决定哪一个适合您的项目需要。