Recherche sur le mécanisme de verrouillage du cache des fonctions concurrentes de Golang

Dans les scénarios à forte concurrence, l'utilisation du cache de fonctions peut éviter des calculs répétés, et l'introduction d'un mécanisme de verrouillage peut garantir la sécurité de la concurrence des données mises en cache. La mise en cache peut être implémentée en langage Go via sync.Map, et un verrou mutex est introduit pour chaque élément du cache afin d'assurer la sécurité de la concurrence. Dans un cas pratique, le mécanisme de cache et de verrouillage est utilisé pour mettre efficacement en cache les résultats de calcul de la séquence de Fibonacci.

Exploration du mécanisme de verrouillage du cache des fonctions simultanées dans le langage Go

Avant-propos
Dans les scénarios à haute concurrence, afin d'éviter les calculs répétés de fonctions, vous pouvez utiliser le mécanisme de cache. Afin de garantir la sécurité simultanée des données mises en cache, un mécanisme de verrouillage doit être introduit. Cet article abordera l'implémentation de la fonction de verrouillage du cache en langage Go et la démontrera à travers des cas pratiques.

Implémentation du cache
Le moyen le plus simple d'implémenter la mise en cache des fonctions consiste à utiliser le type sync.Map, qui fournit une fonctionnalité de mappage clé-valeur efficace et sécurisée pour les threads.

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

Mécanisme de verrouillage
Afin de garantir la sécurité de la concurrence des données mises en cache, un verrou mutex peut être introduit pour chaque élément du 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)
}

Cas pratique
Ce qui suit est un exemple simple utilisant le mécanisme de cache et de verrouillage, qui montre comment mettre en cache les résultats de calcul de la séquence de 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)
    }
}

Résultats d'exécution

0
1
1
2
3
5
8
13
21
34

Dans cet exemple, une goroutine concurrente calcule simultanément la séquence de Fibonacci et met correctement en cache les résultats du calcul pour éviter des calculs répétés.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!