Golang関数のパフォーマンス最適化とキャッシュ技術の応用

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)
}

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)
}

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))
}

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