Forschung zum Golang-Cache-Sperrmechanismus für gleichzeitige Funktionen

In Szenarien mit hoher Parallelität kann die Verwendung des Funktionscaches wiederholte Berechnungen vermeiden, und die Einführung eines Sperrmechanismus kann die Parallelitätssicherheit zwischengespeicherter Daten gewährleisten. Caching kann über sync.Map in der Go-Sprache implementiert werden, und für jedes Cache-Element wird eine Mutex-Sperre eingeführt, um Parallelitätssicherheit zu gewährleisten. In einem praktischen Fall werden der Cache- und der Sperrmechanismus verwendet, um die Berechnungsergebnisse der Fibonacci-Folge effizient zwischenzuspeichern.

Erkunden des Cache-Sperrmechanismus gleichzeitiger Funktionen in der Go-Sprache

Vorwort
In Szenarien mit hoher Parallelität können Sie den Cache-Mechanismus verwenden, um wiederholte Berechnungen von Funktionen zu vermeiden. Um die Parallelitätssicherheit zwischengespeicherter Daten zu gewährleisten, muss ein Sperrmechanismus eingeführt werden. In diesem Artikel wird die Implementierung der Funktions-Cache-Sperre in der Go-Sprache erläutert und anhand praktischer Fälle demonstriert.

Cache-Implementierung
Der einfachste Weg, Funktions-Caching zu implementieren, ist die Verwendung des Typs sync.Map, der effiziente und threadsichere Schlüsselwert-Zuordnungsfunktionen bereitstellt.

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

Sperrmechanismus
Um die Parallelitätssicherheit zwischengespeicherter Daten zu gewährleisten, kann für jedes Cache-Element eine Mutex-Sperre eingeführt werden.

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

Praktischer Fall
Das Folgende ist ein einfaches Beispiel mit dem Cache- und Sperrmechanismus, das zeigt, wie die Berechnungsergebnisse der Fibonacci-Sequenz zwischengespeichert werden.

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

Laufende Ergebnisse

0
1
1
2
3
5
8
13
21
34

In diesem Beispiel berechnet die gleichzeitige Goroutine gleichzeitig die Fibonacci-Folge und speichert die Berechnungsergebnisse korrekt zwischen, um wiederholte Berechnungen zu vermeiden.

Das obige ist der detaillierte Inhalt vonForschung zum Golang-Cache-Sperrmechanismus für gleichzeitige Funktionen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!