gcache

gcache是一个高速的单进程缓存模块，提供了并发安全的缓存控制接口。

使用方式：

  1. import "github.com/gogf/gf/os/gcache"

接口文档：

https://godoc.org/github.com/gogf/gf/os/gcache

gcache可以使用New方法创建使用，并且也可以使用包方法使用。在通过包方法使用缓存功能时，操作的是gcache默认提供的一个gcache.Cache对象，具有全局性，因此在使用时注意全局键名的覆盖。

gcache使用的键名类型是interface{}，而不是string类型，这意味着我们可以使用任意类型的变量作为键名，但大多数时候建议使用string或者[]byte作为键名，并且统一键名的数据类型，以便维护。

gcache存储的键值类型是interface{}，也就是说可以存储任意的数据类型，当获取数据时返回的也是interface{}类型，若需要转换为其他的类型可以通过gcache的Get*方法便捷获取常见类型。

另外需要注意的是，gcache的缓存过期时间参数duration的类型为time.Duration类型，在Set缓存变量时，如果缓存时间参数duration = 0表示不过期，duration < 0表示立即过期，expire > 0表示超时过期。

示例1，基本使用

  1. package main
  3. import (
  4.     "fmt"
  5.     "github.com/gogf/gf/os/gcache"
  6. )
  8. func main() {
  9.     // 创建一个缓存对象，
  10.     // 当然也可以便捷地直接使用gcache包方法
  11.     c := gcache.New()
  13.     // 设置缓存，不过期
  14.     c.Set("k1", "v1", 0)
  16.     // 获取缓存
  17.     fmt.Println(c.Get("k1"))
  19.     // 获取缓存大小
  20.     fmt.Println(c.Size())
  22.     // 缓存中是否存在指定键名
  23.     fmt.Println(c.Contains("k1"))
  25.     // 删除并返回被删除的键值
  26.     fmt.Println(c.Remove("k1"))
  28.     // 关闭缓存对象，让GC回收资源
  29.     c.Close()
  30. }

执行后，输出结果为：

  1. v1
  2. 1
  3. true
  4. v1

示例2，缓存控制

  1. package main
  3. import (
  4.     "fmt"
  5.     "github.com/gogf/gf/os/gcache"
  6.     "time"
  7. )
  9. func main() {
  10.     // 当键名不存在时写入，设置过期时间1000毫秒
  11.     gcache.SetIfNotExist("k1", "v1", 1000*time.Millisecond)
  13.     // 打印当前的键名列表
  14.     fmt.Println(gcache.Keys())
  16.     // 打印当前的键值列表
  17.     fmt.Println(gcache.Values())
  19.     // 获取指定键值，如果不存在时写入，并返回键值
  20.     fmt.Println(gcache.GetOrSet("k2", "v2", 0))
  22.     // 打印当前的键值对
  23.     fmt.Println(gcache.Data())
  25.     // 等待1秒，以便k1:v1自动过期
  26.     time.Sleep(time.Second)
  28.     // 再次打印当前的键值对，发现k1:v1已经过期，只剩下k2:v2
  29.     fmt.Println(gcache.Data())
  30. }

执行后，输出结果为：

  1. [k1]
  2. [v1]
  3. v2
  4. map[k1:v1 k2:v2]
  5. map[k2:v2]

示例3，GetOrSetFunc/GetOrSetFuncLock

GetOrSetFunc获取一个缓存值，当缓存不存在时执行指定的f func() interface{}，缓存该f方法的结果值，并返回该结果。

需要注意的是，GetOrSetFunc的缓存方法参数f是在缓存的锁机制外执行，因此在f内部也可以嵌套调用GetOrSetFunc。但如果f的执行比较耗时，高并发的时候容易出现f被多次执行的情况(缓存设置只有第一个执行的f返回结果能够设置成功，其余的被抛弃掉)。

而GetOrSetFuncLock的缓存方法f是在缓存的锁机制内执行，因此可以保证当缓存项不存在时只会执行一次f，但是缓存写锁的时间随着f方法的执行时间而定。

我们来看一个在gf-home项目中使用GetOrSetFunc的示例，该示例遍历检索markdown文件进行字符串检索，并根据指定的搜索key缓存该结果值，因此多次搜索该key时，第一次会执行目录遍历搜索，后续将直接使用缓存结果。

https://github.com/gogf/gf-home/blob/master/app/lib/doc/doc.go

  1. // 根据关键字进行markdown文档搜索，返回文档path列表
  2. func SearchMdByKey(key string) []string {
  3.     glog.Cat("search").Println(key)
  4.     v := cache.GetOrSetFunc("doc_search_result_" + key, func() interface{} {
  5.         // 当该key的检索缓存不存在时，执行检索
  6.         array    := garray.NewStringArray(0, 0, false)
  7.         docPath  := g.Config().GetString("doc.path")
  8.         paths    := cache.GetOrSetFunc("doc_files_recursive", func() interface{} {
  9.             // 当目录列表不存在时，执行检索
  10.             paths, _ := gfile.ScanDir(docPath, "*.md", true)
  11.             return paths
  12.         }, 0)
  13.         // 遍历markdown文件列表，执行字符串搜索
  14.         for _, path := range gconv.Strings(paths) {
  15.             content := gfcache.GetContents(path)
  16.             if len(content) > 0 {
  17.                 if strings.Index(content, key) != -1 {
  18.                     index := gstr.Replace(path, ".md", "")
  19.                     index  = gstr.Replace(index, docPath, "")
  20.                     array.Append(index)
  21.                 }
  22.             }
  23.         }
  24.         return array.Slice()
  25.     }, 0)
  27.     return gconv.Strings(v)
  28. }

示例4，LRU缓存淘汰控制

  1. package main
  3. import (
  4.     "github.com/gogf/gf/os/gcache"
  5.     "time"
  6.     "fmt"
  7. )
  9. func main() {
  10.     // 设置LRU淘汰数量
  11.     c := gcache.New(2)
  13.     // 添加10个元素，不过期
  14.     for i := 0; i < 10; i++ {
  15.         c.Set(i, i, 0)
  16.     }
  17.     fmt.Println(c.Size())
  18.     fmt.Println(c.Keys())
  20.     // 读取键名1，保证该键名是优先保留
  21.     fmt.Println(c.Get(1))
  23.     // 等待一定时间后(默认1秒检查一次)，
  24.     // 元素会被按照从旧到新的顺序进行淘汰
  25.     time.Sleep(2*time.Second)
  26.     fmt.Println(c.Size())
  27.     fmt.Println(c.Keys())
  28. }

执行后，输出结果为：

  1. 10
  2. [2 4 5 7 8 9 0 1 3 6]
  3. 1
  4. 2
  5. [1 9]

性能测试

测试环境

  1. CPU: Intel(R) Core(TM) i5-4460  CPU @ 3.20GHz
  2. MEM: 8GB
  3. SYS: Ubuntu 16.04 amd64

测试结果

  1. john@john-B85M:~/Workspace/Go/GOPATH/src/github.com/gogf/gf/os/gcache$ go test *.go -bench=".*" -benchmem
  2. goos: linux
  3. goarch: amd64
  4. Benchmark_CacheSet-4                       2000000        897 ns/op      249 B/op        4 allocs/op
  5. Benchmark_CacheGet-4                       5000000        202 ns/op       49 B/op        1 allocs/op
  6. Benchmark_CacheRemove-4                   50000000       35.7 ns/op        0 B/op        0 allocs/op
  7. Benchmark_CacheLruSet-4                    2000000        880 ns/op      399 B/op        4 allocs/op
  8. Benchmark_CacheLruGet-4                    3000000        212 ns/op       33 B/op        1 allocs/op
  9. Benchmark_CacheLruRemove-4                50000000       35.9 ns/op        0 B/op        0 allocs/op
  10. Benchmark_InterfaceMapWithLockSet-4        3000000        477 ns/op       73 B/op        2 allocs/op
  11. Benchmark_InterfaceMapWithLockGet-4       10000000        149 ns/op        0 B/op        0 allocs/op
  12. Benchmark_InterfaceMapWithLockRemove-4    50000000       39.8 ns/op        0 B/op        0 allocs/op
  13. Benchmark_IntMapWithLockWithLockSet-4      5000000        304 ns/op       53 B/op        0 allocs/op
  14. Benchmark_IntMapWithLockGet-4             20000000        164 ns/op        0 B/op        0 allocs/op
  15. Benchmark_IntMapWithLockRemove-4          50000000       33.1 ns/op        0 B/op        0 allocs/op
  16. PASS
  17. ok   command-line-arguments 47.503s