Perkongsian petua pengoptimuman prestasi cache fungsi Golang

Caching fungsi ialah teknologi pengoptimuman prestasi yang menyimpan hasil panggilan fungsi untuk digunakan semula dan mengelakkan pengiraan berulang. Dalam Go, caching fungsi boleh dilaksanakan dengan menggunakan peta atau sync.Map, dan strategi caching yang berbeza boleh diguna pakai mengikut senario tertentu. Contohnya, strategi cache mudah menggunakan semua parameter fungsi sebagai kunci cache, manakala strategi cache yang diperhalusi hanya menyimpan sebahagian daripada hasil untuk menjimatkan ruang. Selain itu, strategi caching selamat dan penolakan serentak boleh mengoptimumkan lagi prestasi cache. Dengan menggunakan teknik ini, kecekapan pelaksanaan panggilan fungsi boleh dipertingkatkan dengan ketara.

Perkongsian petua pengoptimuman prestasi caching fungsi Golang

Caching fungsi ialah teknologi pengoptimuman prestasi biasa yang boleh menyimpan hasil panggilan fungsi untuk digunakan semula pada masa hadapan. Ini meningkatkan prestasi dengan mengelak daripada melakukan pengiraan yang sama setiap kali fungsi dipanggil.

Strategi caching

Strategi caching mudah: Gunakan semua parameter fungsi sebagai kunci cache dan cache hasil fungsi terus dalam peta.

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
}

Strategi caching yang diperhalusi: Hanya sebahagian daripada hasil boleh dicache berdasarkan parameter fungsi untuk menjimatkan ruang. Sebagai contoh, untuk fungsi yang mengira luas bulatan, kita hanya boleh cache hasil dengan jejari antara 0 dan 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 selamat-konkurensi: Dalam persekitaran serentak, data selamat serentak struktur perlu digunakan untuk melaksanakan caching fungsi. Contohnya, anda boleh menggunakan 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")
    }
}

Strategi pembatalan:

Kadangkala, keputusan dalam cache mungkin menjadi tidak sah. Sebagai contoh, jika pelaksanaan fungsi yang mengira kawasan bulatan berubah, hasil cache akan menjadi tidak sah. Anda boleh mengendalikan situasi ini dengan menetapkan masa tamat tempoh atau mengosongkan cache apabila hasil fungsi berubah.

Kes praktikal🎜🎜 Katakan kita mempunyai fungsi slowOperation(), yang pengiraannya sangat memakan masa. Kita boleh menggunakan cache fungsi untuk mengoptimumkannya: 🎜

执行 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

🎜 Hasil output: 🎜rrreee🎜 Seperti yang dapat dilihat daripada hasil output, menggunakan cache fungsi sangat mengurangkan masa pelaksanaan operasi perlahan. 🎜

Atas ialah kandungan terperinci Perkongsian petua pengoptimuman prestasi cache fungsi Golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!