Le principe de mise en œuvre de la façon dont le cache et le verrouillage fonctionnent ensemble dans Golang.

Principe de la façon dont le cache et le verrouillage fonctionnent ensemble dans Golang

En programmation simultanée, le cache et le verrouillage sont deux concepts courants. Ils sont utilisés respectivement pour optimiser les performances du programme et maintenir la cohérence des données. Dans Golang, la mise en cache et les verrous sont généralement utilisés ensemble pour implémenter certains scénarios à haute concurrence. Cet article présentera le principe de mise en œuvre de la façon dont le cache et le verrouillage fonctionnent ensemble dans Golang.

1. Implémentation du cache dans Golang

Le cache est un mécanisme permettant de stocker les résultats des calculs en mémoire pour éviter les calculs répétés et accélérer l'accès aux données. Dans Golang, la bibliothèque standard fournit un package de synchronisation, qui inclut un type appelé Map, qui peut être utilisé pour implémenter la mise en cache.

sync.Map est un cache thread-safe qui prend en charge l'accès simultané au cache. Vous trouverez ci-dessous un exemple d'utilisation de sync.Map pour implémenter la mise en cache.

package main

import (
    "fmt"
    "sync"
)

func main() {
    var cache sync.Map

    // 设置缓存
    cache.Store("hello", "world")

    // 获取缓存
    val, ok := cache.Load("hello")
    if ok {
        fmt.Println(val)
    }
}

Dans l'exemple ci-dessus, nous avons d'abord créé un cache de variables de type sync.Map. Nous utilisons ensuite la méthode Store pour stocker la valeur « world » dans le cache et l'associer à la clé « hello ». Enfin, nous utilisons la méthode Load pour récupérer la valeur avec la clé "hello" depuis le cache.

2. Implémentation de verrous dans Golang

Lorsque plusieurs coroutines se disputent des ressources partagées, la synchronisation des verrous est une méthode courante. Dans Golang, la bibliothèque standard propose trois types de verrous : sync.Mutex, sync.RWMutex et sync.WaitGroup.

sync.Mutex est le type de verrouillage le plus basique. Il propose deux méthodes simples : verrouiller et déverrouiller. Lorsqu'une coroutine appelle la méthode Lock, si le verrou n'est pas occupé par d'autres coroutines, alors elle acquerra le verrou. Si le verrou est déjà occupé par une autre coroutine, la méthode Lock se bloquera jusqu'à ce que le verrou soit libéré. Lorsqu'une coroutine appelle la méthode Unlock, elle libère le verrou.

sync.Mutex est largement utilisé pour implémenter un accès mutuellement exclusif afin d'empêcher plusieurs coroutines de modifier la même variable au même moment. Vous trouverez ci-dessous un exemple d'utilisation de sync.Mutex pour implémenter un verrou.

package main

import (
    "fmt"
    "sync"
)

var counter int
var lock sync.Mutex

func main() {
    var wg sync.WaitGroup
    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go func() {
            lock.Lock()
            counter++
            lock.Unlock()
            wg.Done()
        }()
    }
    wg.Wait()
    fmt.Println(counter)
}

Dans l'exemple ci-dessus, nous avons défini une variable nommée compteur et une variable de verrouillage verrou de type sync.Mutex. Ensuite, nous démarrons 1000 coroutines. Chaque coroutine va d'abord acquérir le verrou, puis augmenter la valeur du compteur et enfin libérer le verrou. En raison de l'existence du verrou, plusieurs coroutines peuvent faire fonctionner les compteurs en toute sécurité, garantissant ainsi la cohérence des données.

3. Principe de fonctionnement du cache et du verrou dans Golang

Lorsque nous devons lire et écrire le cache simultanément, nous devons utiliser des verrous pour garantir la cohérence des données. C'est ainsi que la mise en cache et le verrouillage fonctionnent ensemble.

Ce qui suit est un exemple d'utilisation de sync.Mutex pour implémenter la mise en cache.

package main

import (
    "fmt"
    "sync"
)

type cache struct {
    data map[string]string
    lock sync.Mutex
}

func newCache() *cache {
    return &cache{
        data: make(map[string]string),
    }
}

func (c *cache) set(key string, val string) {
    c.lock.Lock()
    defer c.lock.Unlock()
    c.data[key] = val
}

func (c *cache) get(key string) (string, bool) {
    c.lock.Lock()
    defer c.lock.Unlock()
    val, ok := c.data[key]
    return val, ok
}

func main() {
    c := newCache()
    c.set("hello", "world")
    val, ok := c.get("hello")
    if ok {
        fmt.Println(val)
    }
}

Dans l'exemple ci-dessus, nous avons défini une structure nommée cache, qui contient des données de type map et un verrou de type Mutex. Nous utilisons la méthode set pour stocker les données dans le cache et la méthode get pour obtenir les données du cache. Dans les méthodes set et get, nous utilisons la méthode lock pour acquérir le verrou et le libérer lorsque la méthode termine son exécution. En raison de l'existence du verrou, plusieurs coroutines peuvent lire et écrire en toute sécurité les caches, garantissant ainsi la cohérence des données.

Pour résumer, le cache et le verrouillage sont deux concepts courants, qui sont utilisés respectivement pour optimiser les performances du programme et maintenir la cohérence des données. Dans Golang, nous pouvons implémenter la mise en cache et le verrouillage via le type Map et le type Mutex dans le package de synchronisation. Lorsque la lecture et l'écriture simultanées dans le cache sont requises, nous devons utiliser des verrous pour garantir la cohérence des données. Le travail collaboratif du cache et des verrous peut améliorer efficacement les performances de concurrence du programme.

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!