Utilisez la fonction sync.Map dans Golang pour implémenter une cartographie simultanée et sécurisée

Titre : Utilisation de la fonction sync.Map dans Golang pour implémenter une cartographie simultanée et sécurisée

Introduction :
Dans la programmation simultanée, plusieurs goroutines lisent et écrivent la même structure de données en même temps, ce qui entraînera une concurrence et une incohérence des données question. Afin de résoudre ce problème, le langage Go fournit le type Map dans le package de synchronisation, qui est un mappage sécurisé pour la concurrence qui peut effectuer en toute sécurité des opérations de lecture et d'écriture dans plusieurs goroutines. Cet article explique comment utiliser la fonction sync.Map pour implémenter un mappage simultané et sécurisé, et donne des exemples de code correspondants.

Présentation :
sync.Map est un type de mappage thread-safe fourni dans la bibliothèque standard du langage Go, qui peut être utilisé pour lire et écrire en toute sécurité des opérations dans plusieurs goroutines. Il fournit les fonctions principales suivantes :

1. Load(key interface{}) (value interface{}, ok bool) : Charge la valeur correspondante en fonction de la clé. Si la clé existe, la valeur correspondante et true sont renvoyés ; sinon, nil et false sont renvoyés.
2. Store(key, value interface{}) : stocke les paires clé-valeur.
3. Delete(key interface{}) : supprime la clé spécifiée et sa valeur correspondante.
4. LoadOrStore(key, value interface{}) (actual interface{},chargé bool) : charge la valeur correspondante en fonction de la clé. Si la clé existe, renvoie la valeur existante et true sinon, stocke la valeur-clé donnée ; . et renvoie la valeur et false.
5. Range(f func(key, value interface{}) bool) : Parcourez toutes les paires clé-valeur et transmettez-les comme paramètres à la fonction f.

Exemple de code :
Ce qui suit est un exemple de code simple qui utilise la fonction sync.Map pour implémenter un mappage simultané et sécurisé :

package main

import (
    "fmt"
    "sync"
)

func main() {
    var sm sync.Map

    // 存储键值对
    sm.Store("A", 1)
    sm.Store("B", 2)
    sm.Store("C", 3)

    // 加载键值对
    value, ok := sm.Load("A")
    if ok {
        fmt.Println("Value of A:", value)
    }

    // 遍历键值对
    sm.Range(func(key, value interface{}) bool {
        fmt.Printf("Key: %s, Value: %d
", key, value)
        return true
    })

    // 删除键值对
    sm.Delete("B")
    _, ok = sm.Load("B")
    if !ok {
        fmt.Println("B does not exist")
    }
}

Résultats d'exécution :

Value of A: 1
Key: A, Value: 1
Key: C, Value: 3
B does not exist

Conclusion :
L'utilisation de la fonction sync.Map peut obtenir des résultats sûrs et les opérations de mappage simultanées, les problèmes de course aux données et d'incohérence sont évités. En programmation simultanée, si vous avez besoin de lire et d'écrire la carte, il est recommandé d'utiliser sync.Map pour garantir la stabilité et l'exactitude du programme. Veuillez noter que sync.Map est limité et ne convient pas aux scénarios nécessitant un grand nombre d'opérations de mappage et des performances élevées. Pour ces scénarios, nous pouvons envisager d'utiliser d'autres implémentations de mappage plus efficaces et sécurisées.

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!