在 go 语言中，函数缓存失效场景包括：参数改变、全局变量修改、程序重新部署、并发修改。处理策略包括：1. 惰性计算（首次调用执行计算并缓存结果）；2. 过期策略（定期检查缓存结果有效性）；3. 通知机制（订阅事件或消息来自动失效缓存）；4. 排除失效场景（修改代码逻辑或引入其他技术）。实战案例：电商网站获取产品价格的函数，可使用过期策略定期检查价格变化，并使用锁机制防止并发修改。
Go 语言函数缓存失效场景及处理策略
在 Go 语言中，函数缓存可以极大提升代码性能，但它并非完美无缺。函数缓存失效是不可避免的，本文将介绍常見的失效场景及其处理策略。
失效场景
立即学习“go语言免费学习笔记（深入）”；
- 参数改变：函数缓存依赖于函数参数，如果参数发生改变，缓存将失效。
- 全局变量修改：如果函数访问共享的全局变量，而该变量发生修改，缓存将失效。
- 程序重新部署：程序重新部署后，所有函数缓存将失效。
- 并发修改：并发环境下，多个并发执行的 goroutine 可能同时修改共享数据，导致缓存失效。
处理策略
1. 惰性计算
惰性计算是一种延迟计算的策略，仅在首次调用函数时执行计算并缓存结果， последующие调用将直接从缓存中获取结果。
import "sync"
var m sync.Map
func Fibonacci(n int) int {
if n < 2 {
return n
}
var result int
val, exists := m.Load(n)
if exists {
result = val.(int)
} else {
result = Fibonacci(n-1) + Fibonacci(n-2)
m.Store(n, result)
}
return result
}2. 过期策略
过期策略是定期检查缓存中存储的结果是否仍然有效，如果无效则将其从缓存中删除。
import (
"sync"
"time"
)
type entry struct {
value interface{}
expiry time.Time
}
var cache = sync.Map{}
func SetWithExpiry(key, value interface{}, expiry time.Duration) {
cache.Store(key, &entry{value: value, expiry: time.Now().Add(expiry)})
}
func Get(key interface{}) (interface{}, bool) {
val, exists := cache.Load(key)
if !exists {
return nil, false
}
entry := val.(*entry)
if entry.expiry.Before(time.Now()) {
cache.Delete(key)
return nil, false
}
return entry.value, true
}3. 通知机制
可以通过订阅事件或消息来自动失效函数缓存，当相关数据发生变化时，触发事件或消息通知缓存失效。
import (
"context"
"sync"
)
var results = sync.Map{}
var invalidations = make(chan struct{})
func Memoize(ctx context.Context, f func() (interface{}, error)) (interface{}, error) {
key := f
val, ok := results.Load(key)
if ok {
return val.(interface{}), nil
}
result, err := f()
if err != nil {
return nil, err
}
invalidations <- struct{}{} // 触发缓存失效
results.Store(key, result)
return result, nil
}4. 排除失效场景
有时，我们可以通过修改代码逻辑或引入其他技术来排除失效场景。例如，使用不可变数据结构或对共享数据进行同步访问。
实战案例
假设我们在一个电商网站中，有一个函数 GetProductPrice 获取产品的价格。由于产品价格经常变动，我们需要使用函数缓存来优化性能。
import (
"sync"
"time"
)
type product struct {
ID int
Price float64
}
var cache = sync.Map{}
// GetProductPrice 从缓存获取产品价格，如果缓存中没有，则从数据库中获取并缓存
func GetProductPrice(id int) (float64, error) {
val, exists := cache.Load(id)
if exists {
return val.(float64), nil
}
product, err := getProductFromDatabase(id)
if err != nil {
return 0, err
}
cache.Store(id, product.Price)
return product.Price, nil
}由于产品价格会定期变动，我们需要使用过期策略来管理缓存，并定期检查价格是否发生变化。
import (
"context"
"sync"
"time"
)
var cache = sync.Map{}
var invalidations = make(chan struct{})
func GetProductPriceWithExpiry(id int) (float64, error) {
ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
defer cancel()
for {
val, exists := cache.Load(id)
if exists {
entry := val.(*entry)
if entry.expiry.Before(time.Now()) {
cache.Delete(id)
} else {
return val.(float64), nil
}
}
product, err := getProductFromDatabase(id)
if err != nil {
return 0, err
}
invalidations <- struct{}{}
cache.Store(id, &entry{value: product.Price, expiry: time.Now().Add(1 * time.Minute)})
return product.Price, nil
}
} 
