Golang高性能缓存库GCache使用指南

GCache是一个支持过期缓存、LFU、LRU和ARC算法的Golang缓存库。

特性

• 支持过期缓存、LFU、LRU和ARC算法
• 线程安全
• 支持淘汰、清除和添加条目的事件处理器(可选)
• 自动加载不存在的缓存(可选)

安装

$ go get github.com/bluele/gcache

示例代码

1. 手动设置键值对

package main

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

func main() {
  // 创建容量为20的LRU缓存
  gc := gcache.New(20).
    LRU().
    Build()
  gc.Set("key", "ok")
  value, err := gc.Get("key")
  if err != nil {
    panic(err)
  }
  fmt.Println("Get:", value)
}

输出:

Get: ok

2. 设置带过期时间的键值对

package main

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

func main() {
  gc := gcache.New(20).
    LRU().
    Build()
  // 设置10秒后过期的键值对
  gc.SetWithExpire("key", "ok", time.Second*10)
  value, _ := gc.Get("key")
  fmt.Println("Get:", value)

  // 等待值过期
  time.Sleep(time.Second*10)

  value, err := gc.Get("key")
  if err != nil {
    panic(err)
  }
  fmt.Println("Get:", value)
}

输出:

Get: ok
// 10秒后, 再次尝试:
panic: ErrKeyNotFound

3. 自动加载值

package main

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

func main() {
  gc := gcache.New(20).
    LRU().
    // 定义加载函数
    LoaderFunc(func(key interface{}) (interface{}, error) {
      return "ok", nil
    }).
    Build()
  value, err := gc.Get("key")
  if err != nil {
    panic(err)
  }
  fmt.Println("Get:", value)
}

输出:

Get: ok

4. 带过期时间的自动加载

package main

import (
  "fmt"
  "time"

  "github.com/bluele/gcache"
)

func main() {
  var evictCounter, loaderCounter, purgeCounter int
  gc := gcache.New(20).
    LRU().
    // 定义带过期时间的加载函数
    LoaderExpireFunc(func(key interface{}) (interface{}, *time.Duration, error) {
      loaderCounter++
      expire := 1 * time.Second
      return "ok", &expire, nil
    }).
    // 定义淘汰事件处理器
    EvictedFunc(func(key, value interface{}) {
      evictCounter++
      fmt.Println("evicted key:", key)
    }).
    // 定义清除事件处理器
    PurgeVisitorFunc(func(key, value interface{}) {
      purgeCounter++
      fmt.Println("purged key:", key)
    }).
    Build()
  value, err := gc.Get("key")
  if err != nil {
    panic(err)
  }
  fmt.Println("Get:", value)
  time.Sleep(1 * time.Second)
  value, err = gc.Get("key")
  if err != nil {
    panic(err)
  }
  fmt.Println("Get:", value)
  gc.Purge()
  if loaderCounter != evictCounter+purgeCounter {
    panic("bad")
  }
}

输出:

Get: ok
evicted key: key
Get: ok
purged key: key

缓存算法

1. LFU (Least-Frequently Used)

淘汰使用频率最低的条目。

func main() {
  // 容量为10的LFU缓存
  gc := gcache.New(10).
    LFU().
    Build()
  gc.Set("key", "value")
}

2. LRU (Least Recently Used)

淘汰最近最少使用的条目。

func main() {
  // 容量为10的LRU缓存
  gc := gcache.New(10).
    LRU().
    Build()
  gc.Set("key", "value")
}

3. ARC (Adaptive Replacement Cache)

在LRU和LFU之间动态平衡以获得更好的综合效果。

func main() {
  // 容量为10的ARC缓存
  gc := gcache.New(10).
    ARC().
    Build()
  gc.Set("key", "value")
}

4. SimpleCache (默认)

没有明确的淘汰优先级，依赖于键值映射的顺序。

func main() {
  // 容量为10的简单缓存
  gc := gcache.New(10).Build()
  gc.Set("key", "value")
  v, err := gc.Get("key")
  if err != nil {
    panic(err)
  }
}

加载缓存

如果指定了LoaderFunc，缓存会自动加载值，并将它们存储在缓存中直到被淘汰或手动失效。

func main() {
  gc := gcache.New(10).
    LRU().
    LoaderFunc(func(key interface{}) (interface{}, error) {
      return "value", nil
    }).
    Build()
  v, _ := gc.Get("key")
  // 输出: "value"
  fmt.Println(v)
}

过期缓存

func main() {
  // LRU缓存，容量10，1小时后过期
  gc := gcache.New(10).
    LRU().
    Expiration(time.Hour).
    Build()
}

事件处理器

1. 淘汰事件处理器

func main() {
  gc := gcache.New(2).
    EvictedFunc(func(key, value interface{}) {
      fmt.Println("evicted key:", key)
    }).
    Build()
  for i := 0; i < 3; i++ {
    gc.Set(i, i*i)
  }
}

输出:

evicted key: 0

2. 添加事件处理器

func main() {
  gc := gcache.New(2).
    AddedFunc(func(key, value interface{}) {
      fmt.Println("added key:", key)
    }).
    Build()
  for i := 0; i < 3; i++ {
    gc.Set(i, i*i)
  }
}

输出:

added key: 0
added key: 1
added key: 2

作者

Jun Kimura