Golang高性能通用线程安全缓存库icache使用指南

icache是一个轻量级、高性能、线程安全的Go语言缓存库，具有零外部依赖的特点。下面我将详细介绍icache的使用方法。

基本特性

1. 线程安全：内置并发控制机制
2. 高性能：基于高效数据结构实现
3. 零依赖：不依赖任何第三方库
4. 多种淘汰策略：支持LRU、LFU等
5. 简单API：易于集成和使用

安装

go get github.com/icache/icache

基本使用示例

1. 创建缓存实例

package main

import (
	"fmt"
	"github.com/icache/icache"
	"time"
)

func main() {
	// 创建一个默认配置的缓存实例
	cache := icache.New()
	
	// 带配置的创建方式
	cacheWithConfig := icache.New(
		icache.WithMaxSize(1000),      // 最大容量
		icache.WithTTL(5*time.Minute), // 默认过期时间
		icache.WithEvictionPolicy(icache.LRU), // 淘汰策略
	)
	
	_ = cacheWithConfig // 避免未使用警告
}

2. 基本CRUD操作

func basicOperations() {
	cache := icache.New()
	
	// 设置值
	cache.Set("key1", "value1")
	cache.SetWithTTL("key2", "value2", 10*time.Minute)
	
	// 获取值
	if val, ok := cache.Get("key1"); ok {
		fmt.Println("key1:", val)
	}
	
	// 删除值
	cache.Delete("key1")
	
	// 检查是否存在
	if cache.Has("key1") {
		fmt.Println("key1 exists")
	} else {
		fmt.Println("key1 does not exist")
	}
	
	// 清空缓存
	cache.Clear()
}

3. 高级功能

func advancedFeatures() {
	cache := icache.New(
		icache.WithMaxSize(100),
		icache.WithTTL(30*time.Minute),
	)
	
	// 获取或计算模式
	value, err := cache.GetOrCompute("expensive_key", func() (interface{}, error) {
		// 这里执行昂贵的计算或IO操作
		return "computed_value", nil
	})
	
	if err != nil {
		fmt.Println("Error:", err)
	} else {
		fmt.Println("Value:", value)
	}
	
	// 批量操作
	items := map[string]interface{}{
		"batch_key1": "value1",
		"batch_key2": "value2",
	}
	cache.SetAll(items)
	
	// 获取所有键
	keys := cache.Keys()
	fmt.Println("All keys:", keys)
	
	// 统计信息
	stats := cache.Stats()
	fmt.Printf("Cache stats: %+v\n", stats)
}

4. 事件监听

func eventListeners() {
	cache := icache.New(
		icache.WithEvictionListener(func(key string, value interface{}, reason icache.EvictionReason) {
			fmt.Printf("Key %s evicted. Reason: %v\n", key, reason)
		}),
		icache.WithExpirationListener(func(key string, value interface{}) {
			fmt.Printf("Key %s expired\n", key)
		}),
	)
	
	_ = cache // 避免未使用警告
}

性能优化建议

1. 合理设置缓存大小：根据应用内存情况设置最大容量
2. 选择合适的淘汰策略：
   • LRU：最近最少使用（默认）
   • LFU：最不经常使用
   • FIFO：先进先出
3. 批量操作：尽可能使用SetAll等批量方法
4. 合理设置TTL：根据数据更新频率设置过期时间

实际应用示例

package main

import (
	"fmt"
	"github.com/icache/icache"
	"net/http"
	"time"
)

var cache = icache.New(
	icache.WithMaxSize(1000),
	icache.WithTTL(10*time.Minute),
)

func expensiveOperation(param string) (string, error) {
	// 模拟耗时操作
	time.Sleep(500 * time.Millisecond)
	return "result_for_" + param, nil
}

func cachedHandler(w http.ResponseWriter, r *http.Request) {
	param := r.URL.Query().Get("param")
	if param == "" {
		http.Error(w, "param is required", http.StatusBadRequest)
		return
	}
	
	// 尝试从缓存获取
	if val, ok := cache.Get(param); ok {
		fmt.Fprintf(w, "Cached result: %s", val)
		return
	}
	
	// 缓存未命中，执行计算
	result, err := expensiveOperation(param)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	
	// 存入缓存
	cache.Set(param, result)
	
	fmt.Fprintf(w, "Fresh result: %s", result)
}

func main() {
	http.HandleFunc("/", cachedHandler)
	fmt.Println("Server started on :8080")
	http.ListenAndServe(":8080", nil)
}

总结

icache是一个功能强大且易于使用的Go语言缓存库，特别适合需要高性能缓存解决方案的应用场景。它的零依赖特性使得集成非常简单，而丰富的配置选项和API可以满足各种复杂需求。

通过合理配置和使用icache，可以显著提升应用程序的性能，特别是在处理重复计算或频繁访问的数据时。