Golang function cache failure scenarios and processing strategies

In the Go language, function cache failure scenarios include: parameter changes, global variable modifications, program redeployment, and concurrent modifications. Processing strategies include: 1. Lazy calculation (the first call to perform calculations and cache the results); 2. Expiration strategy (regularly check the validity of cached results); 3. Notification mechanism (subscribe to events or messages to automatically invalidate the cache); 4. Exclude invalidation Scenario (modify code logic or introduce other technologies). Practical case: The e-commerce website uses a function to obtain product prices. It can use the expiration strategy to regularly check price changes, and use a lock mechanism to prevent concurrent modifications.

Go language function cache failure scenarios and processing strategies

In the Go language, function caching can greatly improve code performance. But it's not perfect. Function cache invalidation is inevitable. This article will introduce common invalidation scenarios and their handling strategies.

Invalidation scenario

• Parameter change: Function cache depends on function parameters. If the parameters change, the cache will be invalid.
• Global variable modification: If a function accesses a shared global variable and the variable is modified, the cache will be invalid.
• Program redeployment: After the program is redeployed, all function caches will be invalid.
• Concurrent modification: In a concurrent environment, multiple concurrently executed goroutines may modify shared data at the same time, causing cache failure.

Processing strategy

1. Lazy calculation

Lazy calculation is a delayed calculation strategy. The calculation is performed and the result is cached when the function is called for the first time, the последующие call will get the result directly from the cache.

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. Expiration strategy

The expiration strategy is to regularly check whether the results stored in the cache are still valid, and if they are invalid, delete them from the cache.

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. Notification mechanism

You can automatically invalidate the function cache by subscribing to events or messages. When relevant data changes, an event or message is triggered to notify the cache of invalidation.

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. Eliminate failure scenarios

Sometimes, we can eliminate failure scenarios by modifying the code logic or introducing other technologies. For example, using immutable data structures or synchronous access to shared data.

Practical Case

Suppose we are on an e-commerce website and have a function GetProductPrice to get the price of a product. Since product prices change frequently, we need to use function caching to optimize performance.

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
}

Since product prices change regularly, we need to use an expiration policy to manage the cache and regularly check whether the price has changed.

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

The above is the detailed content of Golang function cache failure scenarios and processing strategies. For more information, please follow other related articles on the PHP Chinese website!