Partage de conseils d'optimisation des performances du cache de fonction Golang

La mise en cache des fonctions est une technologie d'optimisation des performances qui stocke les résultats des appels de fonction pour les réutiliser et évite les calculs répétés. Dans Go, la mise en cache des fonctions peut être implémentée à l'aide de map ou sync.Map, et différentes stratégies de mise en cache peuvent être adoptées en fonction de scénarios spécifiques. Par exemple, une stratégie de cache simple utilise tous les paramètres de fonction comme clés de cache, tandis qu'une stratégie de cache raffinée ne met en cache qu'une partie des résultats pour économiser de l'espace. De plus, des stratégies simultanées de mise en cache sécurisée et d’invalidation peuvent optimiser davantage les performances du cache. En appliquant ces techniques, l'efficacité d'exécution des appels de fonction peut être considérablement améliorée.

Partage de conseils d'optimisation des performances de mise en cache des fonctions Golang

La mise en cache des fonctions est une technologie courante d'optimisation des performances qui peut stocker les résultats des appels de fonction pour une réutilisation future. Cela améliore les performances en évitant de faire les mêmes calculs à chaque fois que la fonction est appelée.

Stratégie de mise en cache

Stratégie de mise en cache simple : Utilisez tous les paramètres de la fonction comme clés de cache et mettez en cache les résultats de la fonction directement dans la carte.

func computeCircleArea(radius float64) float64 {
    return math.Pi * radius * radius
}

var areaCache = make(map[float64]float64)

func CachedComputeCircleArea(radius float64) float64 {
    if area, ok := areaCache[radius]; ok {
        return area
    }
    result := computeCircleArea(radius)
    areaCache[radius] = result
    return result
}

Stratégie de mise en cache affinée : Seule une partie des résultats peut être mise en cache en fonction des paramètres de la fonction pour économiser de l'espace. Par exemple, pour une fonction qui calcule l'aire d'un cercle, nous ne pouvons mettre en cache que les résultats avec un rayon compris entre 0 et 1 :

func computeCircleArea(radius float64) float64 {
    return math.Pi * radius * radius
}

var areaCache = make(map[float64]float64)

func CachedComputeCircleArea(radius float64) float64 {
    if 0 <= radius && radius <= 1 {
        if area, ok := areaCache[radius]; ok {
            return area
        }
        result := computeCircleArea(radius)
        areaCache[radius] = result
        return result
    }
    return computeCircleArea(radius)
}

Cache sécurisé pour la concurrence : Dans un environnement concurrent, une donnée sécurisée pour la concurrence La structure doit être utilisée pour implémenter la mise en cache des fonctions. Par exemple, vous pouvez utiliser sync.Map : sync.Map：

package main

import (
    "math"
    "sync"
)

func computeCircleArea(radius float64) float64 {
    return math.Pi * radius * radius
}

var areaCache sync.Map

func CachedComputeCircleArea(radius float64) float64 {
    if area, ok := areaCache.Load(radius); ok {
        return area.(float64)
    }
    result := computeCircleArea(radius)
    areaCache.Store(radius, result)
    return result
}

失效策略：有时，缓存中的结果可能变得无效。例如，如果计算圆形面积的函数的实现发生改变，那么缓存的结果就无效了。您可以通过设定过期时间或在函数结果发生变化时清除缓存来处理这种情况。

实战案例

假设我们有一个函数 slowOperation()

package main

import (
    "sync/atomic"
    "time"
)

var operationCount int64

func slowOperation() float64 {
    count := atomic.AddInt64(&operationCount, 1)
    print("执行 slowOperation ", count, " 次\n")
    time.Sleep(100 * time.Millisecond)
    return 1.0
}

var operationCache sync.Map

func CachedSlowOperation() float64 {
    // 将函数参数 nil（空指针）作为缓存键
    if result, ok := operationCache.Load(nil); ok {
        return result.(float64)
    }
    result := slowOperation()
    operationCache.Store(nil, result)
    return result
}

func main() {
    for i := 0; i < 10; i++ {
        t := time.Now().UnixNano()
        _ = CachedSlowOperation()
        print("优化后花费 ", (time.Now().UnixNano() - t), " ns\n")
        t = time.Now().UnixNano()
        _ = slowOperation()
        print("原始花费 ", (time.Now().UnixNano() - t), " ns\n")
    }
}

Stratégie d'invalidation :

Parfois, les résultats dans le cache peuvent devenir invalides. Par exemple, si l'implémentation d'une fonction qui calcule l'aire d'un cercle change, les résultats mis en cache deviendront invalides. Vous pouvez gérer cette situation en définissant un délai d'expiration ou en vidant le cache lorsque le résultat de la fonction change.

Cas pratique🎜🎜Supposons que nous ayons une fonction slowOperation(), dont le calcul prend beaucoup de temps. Nous pouvons utiliser le cache de fonctions pour l'optimiser : 🎜

执行 slowOperation 1 次
优化后花费 0 ns
执行 slowOperation 2 次
原始花费 100000000 ns
优化后花费 0 ns
执行 slowOperation 3 次
原始花费 100000000 ns
优化后花费 0 ns
执行 slowOperation 4 次
原始花费 100000000 ns
优化后花费 0 ns
执行 slowOperation 5 次
原始花费 100000000 ns
优化后花费 0 ns
执行 slowOperation 6 次
原始花费 100000000 ns
优化后花费 0 ns
执行 slowOperation 7 次
原始花费 100000000 ns
优化后花费 0 ns
执行 slowOperation 8 次
原始花费 100000000 ns
优化后花费 0 ns
执行 slowOperation 9 次
原始花费 100000000 ns
优化后花费 0 ns
执行 slowOperation 10 次
原始花费 100000000 ns
优化后花费 0 ns

🎜 Résultat de sortie : 🎜rrreee🎜 Comme le montre le résultat de sortie, l'utilisation du cache de fonctions réduit considérablement le temps d'exécution des opérations lentes. 🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!