Comment créer une carte en lecture seule dans Golang

Golang est un langage de programmation fortement typé avec des fonctionnalités uniques. L’un d’eux est la carte, qui est une structure de données très pratique en langage Golang. Cependant, bien que map soit puissant, dans certains scénarios d’application, nous n’avons en réalité besoin d’effectuer que des opérations « en lecture seule » sur la map. À l'heure actuelle, vous devez apporter certaines restrictions à la carte pour en faire une carte « en lecture seule » qui ne peut effectuer que des opérations de lecture.

Pourquoi avons-nous besoin d'une opération « lecture seule » ?

En fait, si plusieurs goroutines lisent et écrivent une carte simultanément, des résultats imprévisibles peuvent survenir. Dans ce cas, la carte n'est pas sûre et peut provoquer des erreurs de données, voire un crash. Par conséquent, afin de garantir la sécurité et la stabilité du programme, nous devrons peut-être rendre la carte en lecture seule pour empêcher des modifications supplémentaires.

Comment créer une carte en lecture seule ?

En Golang, nous pouvons utiliser sync.Map pour créer une carte en lecture seule. sync.Map est une implémentation de carte sécurisée simultanément. Ses opérations de lecture et d'écriture sont atomiques, elle est donc thread-safe lorsque plusieurs goroutines lisent et écrivent simultanément. La différence entre sync.Map et la carte ordinaire est que ses types de clé et de valeur sont tous deux interface{}, ce qui lui permet de prendre en charge tout type de données.

Exemple de code :

package main

import (
    "sync"
    "fmt"
)

func main() {
    readOnlyMap := readOnlyMap()
    readOnlyMap.LoadOrStore("foo", "bar")

    fmt.Println(readOnlyMap.Load("foo"))
    readOnlyMap.Delete("foo")
    fmt.Println(readOnlyMap.Load("foo"))
}

func readOnlyMap() *sync.Map {
    m := &sync.Map{}
    return m
}

Dans l'exemple ci-dessus, nous pouvons voir qu'il existe une fonction appelée readOnlyMap(), qui renvoie un pointeur de type *sync.Map. Nous utilisons cette fonction dans la fonction main pour obtenir un objet sync.Map en lecture seule.

Nous pouvons utiliser la fonction Load() pour lire la valeur dans la carte en lecture seule et Delete() pour supprimer une paire clé-valeur. Cependant, nous ne pouvons pas utiliser la fonction Store() pour écrire une nouvelle paire clé-valeur.

Comment utiliser la carte en lecture seule dans goroutine ?

Une caractéristique majeure du langage go est sa prise en charge de la concurrence. Si nous partageons une carte en lecture seule entre plusieurs goroutines, nous devons alors nous assurer qu'elle peut être lue en toute sécurité dans un environnement simultané. Pour ce faire, nous pouvons utiliser sync.RWMutex pour verrouiller. RWMutex est un verrou en lecture-écriture dans le langage go. Nous pouvons l'utiliser pour effectuer une exclusion mutuelle des opérations de lecture et d'écriture.

Exemple de code :

package main

import (
    "sync"
    "fmt"
)

func main() {
    var wg sync.WaitGroup
    readOnlyMap := readOnlyMap()
    readOnlyMap.LoadOrStore("foo", "bar")

    for i := 0; i < 100; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            readOnlyMapOperation(readOnlyMap, "foo")
        }()
    }

    wg.Wait()
}

func readOnlyMapOperation(m *sync.Map, key interface{}) interface{} {
    m.RLock()
    defer m.RUnlock()

    return m.Load(key)
}

func readOnlyMap() *sync.Map {
    m := &sync.Map{}
    return m
}

Dans l'exemple ci-dessus, nous utilisons un objet sync.Map en lecture seule pour lire la valeur de la clé "foo". Nous avons créé 100 goroutines, et chaque goroutine a utilisé la fonction readOnlyMapOperation() pour lire la valeur dans l'objet sync.Map. Le verrou en lecture-écriture sync.RWMutex est utilisé dans la fonction readOnlyMapOperation() pour garantir que les opérations en lecture seule sont thread-safe dans des conditions concurrentes.

Résumé

La carte en lecture seule est une structure de données très pratique dans le langage Go. Elle peut fournir une assistance sûre et efficace lorsque plusieurs goroutines lisent simultanément des données partagées. Dans les applications réelles, nous devons comprendre le mécanisme de verrouillage en lecture-écriture RWMutex dans le code et appliquer les restrictions correctes sur la carte si nécessaire pour obtenir des performances et une sécurité optimales.

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!