golang轻量级内存键值存储插件库cache的使用

golang轻量级内存键值存储插件库cache的使用

Cache是一个轻量级的内存键值存储库，可以存储带有过期时间的数据。

特性

  • 0依赖
  • 约100行代码
  • 100%测试覆盖率

使用示例

下面是一个完整的cache库使用示例：

package main

import (
	"fmt"
	"time"
	
	"github.com/akyoto/cache"
)

func main() {
	// 创建一个新的缓存实例，默认过期时间为5分钟
	c := cache.New(5 * time.Minute)

	// 设置键值对，并指定1分钟后过期
	c.Set("username", "john_doe", 1*time.Minute)
	c.Set("user_id", 12345, 10*time.Minute)

	// 从缓存中获取值
	username, found := c.Get("username")
	if found {
		// 类型断言
		fmt.Println("Username:", username.(string))
	}

	// 获取不存在的键
	value, exists := c.Get("nonexistent_key")
	if !exists {
		fmt.Println("Key does not exist")
	}

	// 删除键
	c.Delete("user_id")

	// 清空缓存
	c.Clear()
}

性能基准测试

BenchmarkGet-12         300000000                3.88 ns/op            0 B/op          0 allocs/op
BenchmarkSet-12         10000000               183 ns/op              48 B/op          2 allocs/op
BenchmarkNew-12         10000000               112 ns/op             352 B/op          5 allocs/op

赞助商

Cedric Fung Scott Rayapoullé Eduard Urbach

更多关于golang轻量级内存键值存储插件库cache的使用的实战教程也可以访问 https://www.itying.com/category-94-b0.html

1 回复

更多关于golang轻量级内存键值存储插件库cache的使用的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


Golang轻量级内存键值存储库Cache使用指南

在Go语言生态中，有几个流行的轻量级内存键值存储库，其中最常用的是go-cache和bigcache。下面我将详细介绍这两个库的使用方法。

1. go-cache 使用指南

go-cache是一个类似memcached的内存键值存储，适用于单机应用程序。

安装

go get github.com/patrickmn/go-cache

基本使用示例

package main

import (
	"fmt"
	"time"
	"github.com/patrickmn/go-cache"
)

func main() {
	// 创建一个默认过期时间为5分钟，每10分钟清理一次过期项的缓存
	c := cache.New(5*time.Minute, 10*time.Minute)

	// 设置键值对，使用默认过期时间
	c.Set("foo", "bar", cache.DefaultExpiration)

	// 设置永不过期的键值对
	c.Set("baz", 42, cache.NoExpiration)

	// 获取值
	if foo, found := c.Get("foo"); found {
		fmt.Println("foo:", foo)
	}

	// 获取多个值
	items := map[string]interface{}{
		"key1": "value1",
		"key2": "value2",
	}
	c.Set("complex", items, cache.DefaultExpiration)

	if x, found := c.Get("complex"); found {
		complexItem := x.(map[string]interface{})
		fmt.Println("complex item:", complexItem)
	}

	// 删除键
	c.Delete("foo")

	// 清空缓存
	c.Flush()

	// 带回调的获取
	c.OnEvicted(func(key string, value interface{}) {
		fmt.Printf("Key %s was evicted\n", key)
	})
}

高级特性

  1. 增量/减量操作：
err := c.Increment("int", 1) // 增1
if err != nil {
	fmt.Println(err)
}

err = c.Decrement("int", 1) // 减1
  1. 带TTL的Add操作：
// 只有键不存在时才添加
added := c.Add("newKey", "value", cache.DefaultExpiration)
fmt.Println("Added:", added)

2. bigcache 使用指南

bigcache是一个快速、并发安全的缓存库，专为高并发场景设计。

安装

go get github.com/allegro/bigcache

基本使用示例

package main

import (
	"fmt"
	"time"
	"github.com/allegro/bigcache"
)

func main() {
	// 配置缓存
	config := bigcache.Config{
		Shards:             1024,           // 分片数量
		LifeWindow:         10 * time.Minute, // 条目生存时间
		CleanWindow:        5 * time.Minute, // 清理间隔
		MaxEntriesInWindow: 1000 * 10 * 60, // 生存窗口内的最大条目数
		MaxEntrySize:       500,            // 最大条目大小(字节)
		Verbose:           true,            // 打印内存分配信息
	}

	cache, err := bigcache.NewBigCache(config)
	if err != nil {
		panic(err)
	}

	// 设置值
	err = cache.Set("my-unique-key", []byte("value"))
	if err != nil {
		panic(err)
	}

	// 获取值
	entry, err := cache.Get("my-unique-key")
	if err != nil {
		panic(err)
	}
	fmt.Println("Entry:", string(entry))

	// 删除键
	err = cache.Delete("my-unique-key")
	if err != nil {
		fmt.Println("Delete error:", err)
	}

	// 获取缓存统计信息
	stats := cache.Stats()
	fmt.Printf("Hits: %d, Misses: %d\n", stats.Hits, stats.Misses)
}

性能优化技巧

  1. 合理设置Shards数量：通常设置为CPU核心数的2-4倍
  2. 调整LifeWindow：根据业务需求设置合理的过期时间
  3. 监控缓存命中率：通过Stats()方法监控缓存性能

选择建议

  • go-cache：适合简单的内存缓存需求，API简单易用
  • bigcache：适合高并发场景，性能更好，内存占用更优

性能对比

特性 go-cache bigcache
并发安全 是 是
分片 否 是
内存优化 一般 优秀
API复杂度 简单 中等
适合场景 小型应用 高并发应用

希望这个指南能帮助你选择合适的缓存库并正确使用它们！

回到顶部