Application technologique de mise en cache d'optimisation des performances de la fonction Golang

Dans l'optimisation des performances des fonctions, la technologie de mise en cache peut réduire le temps d'exécution des fonctions en stockant les données fréquemment consultées dans un stockage rapide. Les bibliothèques de mise en cache « sync/Map » et « bigcache » peuvent être utilisées dans Golang : « sync/Map » convient à la mise en cache de petites données et offre un accès rapide. "bigcache" convient à la mise en cache du Big Data, fournissant des paramètres d'expiration, des stratégies d'expulsion et des opérations simultanées. Des cas pratiques démontrent l'utilisation de la technologie de mise en cache pour optimiser considérablement les performances de calcul des nombres de Fibonacci.

Optimisation des performances des fonctions Golang : application de la technologie de mise en cache

Le cache est une technologie permettant d'optimiser les performances des fonctions en stockant les données fréquemment consultées dans un stockage rapide temporaire. Dans Golang, vous pouvez utiliser diverses bibliothèques de mise en cache, telles que « sync/Map » et « github.com/allegro/bigcache », pour implémenter la mise en cache.

Utilisez sync/Map pour implémenter la mise en cache

"sync/Map" est un mappage de paire clé-valeur simultané et sûr dans Golang. Il convient au stockage de petites données, telles que des chaînes ou des nombres, et est accessible rapidement. Voici comment utiliser "sync/Map" pour implémenter la mise en cache :

import (
    "sync"
)

// 创建一个缓存
var cache = sync.Map{}

// 检查缓存中是否存在键
func isCached(key string) bool {
    _, ok := cache.Load(key)
    return ok
}

// 从缓存中获取值
func getFromCache(key string) (interface{}, bool) {
    return cache.Load(key)
}

// 将值添加到缓存
func addToCache(key string, value interface{}) {
    cache.Store(key, value)
}

Utilisez bigcache pour implémenter la mise en cache

"github.com/allegro/bigcache" est une bibliothèque de mise en cache hautes performances dans Golang, adaptée au stockage du Big Data, tels que des mots Section tranche ou structure. Il fournit des fonctionnalités telles que les paramètres d’expiration, les stratégies de retrait ainsi que le chargement et le stockage simultanés de paires clé-valeur. Voici comment utiliser "bigcache" pour implémenter la mise en cache :

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

// 创建一个缓存
cache, _ := bigcache.NewBigCache(bigcache.DefaultConfig(10 * time.Minute))

// 检查缓存中是否存在键
func isCached(key string) bool {
    entry, _ := cache.Get(key)
    return entry != nil
}

// 从缓存中获取值
func getFromCache(key string) (interface{}, bool) {
    entry, err := cache.Get(key)
    if err != nil {
        return nil, false
    }
    return entry.Value(), true
}

// 将值添加到缓存
func addToCache(key string, value []byte) {
    cache.Set(key, value)
}

Un exemple pratique

Ce qui suit est un exemple pratique d'utilisation de la technologie de mise en cache dans Golang :

Considérons une fonction getFibonacci() qui calcule la séquence de Fibonacci. Pour améliorer les performances, nous pouvons utiliser un cache pour stocker les nombres de Fibonacci précédemment calculés.

import (
    "fmt"
    "time"
    "sync"
)

// 创建一个缓存
var fibonacciCache = sync.Map{}

// 计算斐波那契数
func getFibonacci(n int) int {
    if n == 0 || n == 1 {
        return 1
    }

    // 检查缓存中是否存在值
    cachedValue, ok := fibonacciCache.Load(n)
    if ok {
        return cachedValue.(int)
    }

    // 如果缓存在没有找到值，计算它
    result := getFibonacci(n-1) + getFibonacci(n-2)

    // 将值添加到缓存
    fibonacciCache.Store(n, result)

    return result
}

func main() {
    start := time.Now()
    fmt.Println(getFibonacci(40))
    end := time.Now()
    fmt.Printf("Time taken without cache: %v\n", end.Sub(start))

    // 再次计算同一数值，使用缓存
    start = time.Now()
    fmt.Println(getFibonacci(40))
    end = time.Now()
    fmt.Printf("Time taken with cache: %v\n", end.Sub(start))
}

Sortie :

102334155
Time taken without cache: 1.14490259ms
102334155
Time taken with cache: 714ns

En utilisant la mise en cache, nous réduisons considérablement le temps d'exécution du calcul des nombres de Fibonacci.

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!