Penyelidikan mengenai mekanisme kunci cache fungsi serentak golang

Dalam senario konkurensi tinggi, menggunakan cache fungsi boleh mengelakkan pengiraan berulang, dan memperkenalkan mekanisme kunci boleh memastikan keselamatan serentak data cache. Caching boleh dilaksanakan dalam bahasa Go melalui sync.Map, dan kunci mutex diperkenalkan untuk setiap item cache untuk mencapai keselamatan serentak. Dalam kes praktikal, mekanisme cache dan kunci digunakan untuk menyimpan secara cekap hasil pengiraan jujukan Fibonacci.

Meneroka Mekanisme Kunci Cache bagi Fungsi Serentak dalam Bahasa Go

Kata Pengantar
Dalam senario serentak tinggi, untuk mengelakkan pengiraan berulang penggunaan fungsi mekanisme, anda boleh. Untuk memastikan keselamatan serentak data cache, mekanisme kunci perlu diperkenalkan. Artikel ini akan membincangkan pelaksanaan kunci cache fungsi dalam bahasa Go dan menunjukkannya melalui kes praktikal.

Pelaksanaan cache
Cara paling mudah untuk melaksanakan caching fungsi ialah menggunakan jenis sync.Map, yang menyediakan fungsi pemetaan nilai kunci yang cekap dan selamat benang.

import "sync"

type Cache struct {
    sync.Map
}

func (c *Cache) Get(key string) (interface{}, bool) {
    return c.Load(key)
}

func (c *Cache) Set(key string, value interface{}) {
    c.Store(key, value)
}

Mekanisme kunci
Untuk memastikan keselamatan serentak data cache, kunci mutex boleh diperkenalkan untuk setiap item cache.

type CacheWithLock struct {
    sync.Map
    locks map[string]*sync.Mutex
}

func (c *CacheWithLock) Get(key string) (interface{}, bool) {
    c.locks[key].Lock()
    defer c.locks[key].Unlock()
    return c.Load(key)
}

func (c *CacheWithLock) Set(key string, value interface{}) {
    c.locks[key].Lock()
    defer c.locks[key].Unlock()
    c.Store(key, value)
}

Kes praktikal
Berikut ialah contoh mudah menggunakan mekanisme cache dan kunci, yang menunjukkan cara untuk cache hasil pengiraan jujukan Fibonacci.

package main

import (
    "fmt"
    "sync"
)

var cache *CacheWithLock
var fibFuncs = map[int]func(n int) int{}

func init() {
    cache = &CacheWithLock{
        Map:   make(sync.Map),
        locks: make(map[string]*sync.Mutex),
    }
    fibFuncs[0] = func(n int) int { return 0 }
    fibFuncs[1] = func(n int) int { return 1 }
}

func fib(n int) int {
    f, ok := fibFuncs[n]
    if ok {
        return f(n)
    }
    fibFuncs[n] = func(n int) int {
        return fib(n-1) + fib(n-2)
    }
    return fib(n)
}

func main() {
    for i := 0; i < 10; i++ {
        go func(n int) {
            fmt.Println(cache.Get(n))
            cache.Set(n, fib(n))
        }(i)
    }
}

Hasil berjalan

0
1
1
2
3
5
8
13
21
34

Dalam contoh ini, goroutine serentak mengira jujukan Fibonacci secara serentak, dan menyimpan hasil pengiraan dengan betul untuk mengelakkan pengiraan berulang.

Atas ialah kandungan terperinci Penyelidikan mengenai mekanisme kunci cache fungsi serentak golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!