将缓存添加到 go 函数，就好像它是静态成员一样

Question

假设我有一个昂贵的功能

func veryExpensiveFunction(int) int

这个函数会被同一个号码调用很多次。

是否有一种好方法可以让该函数存储以前的结果以在再次调用该函数时使用，甚至可能对veryExpensiveFunction2 可重用？

显然，可以添加一个参数

func veryExpensiveFunctionCached(p int, cache map[int]int) int {
    if val, ok := cache[p]; ok {
        return val
    }
    result := veryExpensiveFunction(p)
    cache[p] = result
    return result
}

但是现在我必须在某个我不关心它的地方创建缓存。如果可能的话，我宁愿将它作为“静态函数成员”。

在go中模拟静态成员缓存的好方法是什么？

Answer 1

你可以使用闭包；并让闭包管理缓存。

func InitExpensiveFuncWithCache() func(p int) int {
    var cache = make(map[int]int)
    return func(p int) int {
        if ret, ok := cache[p]; ok {
            fmt.Println("from cache")
            return ret
        }
        // expensive computation
        time.Sleep(1 * time.Second)
        r := p * 2
        cache[p] = r
        return r
    }
}

func main() {
    ExpensiveFuncWithCache := InitExpensiveFuncWithCache()
    
    fmt.Println(ExpensiveFuncWithCache(2))
    fmt.Println(ExpensiveFuncWithCache(2))
}

output:
4
from cache
4

veryExpensiveFunctionCached := InitExpensiveFuncWithCache()

并在您的代码中使用包装函数。 你可以试试here。

如果您希望它可重用，请将签名更改为InitExpensiveFuncWithCache(func(int) int)，以便它接受一个函数作为参数。将其包裹在闭包中，用它替换昂贵的计算部分。

Answer 2

如果此缓存将在 http 处理程序中使用，您需要小心同步。在 Go 标准库中，每个 http 请求都在一个专用的 goroutine 中处理，此时我们处于并发和竞争条件的领域。我建议使用RWMutex 以确保数据一致性。

至于缓存注入，您可以在创建 http 处理程序的函数中注入它。 这是一个原型

type Cache struct {
    store map[int]int
    mux   sync.RWMutex
}

func NewCache() *Cache {
    return &Cache{make(map[int]int), sync.RWMutex{}}
}

func (c *Cache) Set(id, value int) {
    c.mux.Lock()
    c.store[id] = id
    c.mux.Unlock()
}

func (c *Cache) Get(id int) (int, error) {
    c.mux.RLock()
    v, ok := c.store[id]
    c.mux.RUnlock()

    if !ok {
        return -1, errors.New("a value with given key not found")
    }

    return v, nil
}


func handleComplexOperation(c *Cache) http.HandlerFunc {
    return http.HandlerFunc(func(rw http.ResponseWriter, r *http.Request){
        
    })
}

Answer 3

Go 标准库使用以下样式来提供“静态”函数（例如 flag.CommandLine），但会利用底层状态：

// "static" function is just a wrapper
func Lookup(p int) int { return expCache.Lookup(p) }

var expCache = NewCache()

func newCache() *CacheExpensive { return &CacheExpensive{cache: make(map[int]int)} }

type CacheExpensive struct {
    l     sync.RWMutex // lock for concurrent access
    cache map[int]int
}

func (c *CacheExpensive) Lookup(p int) int { /*...*/ }

这种设计模式不仅允许简单的一次性使用，还允许隔离使用：

var (
    userX = NewCache()
    userY = NewCache()
)

userX.Lookup(12)
userY.Lookup(42)