Senario kegagalan cache fungsi Golang dan strategi pemprosesan

Dalam bahasa Go, senario kegagalan cache fungsi termasuk: perubahan parameter, pengubahsuaian pembolehubah global, penempatan semula program dan pengubahsuaian serentak. Strategi pemprosesan termasuk: 1. Pengiraan malas (panggilan pertama untuk melakukan pengiraan dan cache keputusan); ); 4. Kecualikan Senario ketidaksahihan (ubah suai logik kod atau perkenalkan teknologi lain). Kes praktikal: Laman web e-dagang menggunakan fungsi untuk mendapatkan harga produk Ia boleh menggunakan strategi tamat tempoh untuk menyemak perubahan harga secara kerap dan menggunakan mekanisme kunci untuk mengelakkan pengubahsuaian serentak.

Senario kegagalan cache fungsi bahasa Go dan strategi pemprosesan

Dalam bahasa Go, cache fungsi boleh meningkatkan prestasi kod, tetapi ia tidak sempurna. Pembatalan cache fungsi tidak dapat dielakkan Artikel ini akan memperkenalkan senario ketidaksahihan biasa dan strategi pemprosesannya.

Senario ketidaksahihan

• Perubahan parameter: Cache fungsi bergantung pada parameter fungsi Jika parameter berubah, cache akan menjadi tidak sah.
• Pengubahsuaian pembolehubah global: Jika fungsi mengakses pembolehubah global yang dikongsi dan pembolehubah itu diubah suai, cache akan menjadi tidak sah.
• Penempatan semula program: Selepas program diatur semula, semua cache fungsi akan menjadi tidak sah.
• Pengubahsuaian serentak: Dalam persekitaran serentak, berbilang goroutin yang dilaksanakan serentak boleh mengubah suai data yang dikongsi pada masa yang sama, menyebabkan kegagalan cache.

Strategi pemprosesan

1. Pengiraan malas

Pengiraan malas ialah strategi pengiraan yang malas, yang hanya melakukan pengiraan dan menyimpan hasil apabila fungsi dipanggil untuk pertama kali terus dari 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. Strategi tamat tempoh

Strategi tamat tempoh adalah dengan kerap menyemak sama ada hasil yang disimpan dalam cache masih sah, dan memadamkannya daripada cache jika tidak sah.

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. Mekanisme pemberitahuan

boleh membatalkan cache fungsi secara automatik dengan melanggan acara atau mesej Apabila data yang berkaitan berubah, peristiwa atau mesej dicetuskan untuk memberitahu cache pembatalan.

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. Hapuskan senario kegagalan

Kadangkala, kita boleh menghapuskan senario kegagalan dengan mengubah suai logik kod atau memperkenalkan teknik lain. Contohnya, menggunakan struktur data tidak berubah atau akses segerak kepada data yang dikongsi.

Kes praktikal

Andaikan kita berada di laman web e-dagang dan mempunyai fungsi GetProductPrice untuk mendapatkan harga sesuatu produk. Memandangkan harga produk kerap berubah, kami perlu menggunakan caching fungsi untuk mengoptimumkan prestasi.

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
}

Memandangkan harga produk sentiasa berubah, kami perlu menggunakan dasar tamat tempoh untuk menguruskan cache dan sentiasa menyemak sama ada harga telah berubah.

rreeee

Atas ialah kandungan terperinci Senario kegagalan cache fungsi Golang dan strategi pemprosesan. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!