Types et utilisation des verrous dans la programmation simultanée de la fonction Golang

Go propose trois types de verrouillage dans la programmation simultanée fonctionnelle : le verrouillage mutex (Mutex), le verrouillage en lecture-écriture (RWMutex) et le verrouillage unique (Once). Les verrous mutex garantissent un accès exclusif, les verrous en lecture-écriture autorisent des lectures simultanées et des écritures uniques, et les verrous à usage unique garantissent qu'un bloc de code n'est exécuté qu'une seule fois. Ces verrous sont utilisés pour coordonner l’accès aux ressources partagées et empêcher les courses aux données. En pratique, les mutex assurent la cohérence des données dans les services Web concurrents, empêchant les requêtes concurrentes de modifier simultanément les structures de données partagées.

Types de verrous et utilisation dans la programmation simultanée fonctionnelle Go

Dans la programmation simultanée fonctionnelle Go, les verrous sont un mécanisme de synchronisation utilisé pour coordonner l'accès aux ressources partagées et empêcher la concurrence des données. Go propose plusieurs types de verrous, chacun avec des caractéristiques différentes et des scénarios applicables.

Verrou Mutex

Mutex est un verrou de base qui ne peut permettre qu'à une seule goroutine d'obtenir des ressources en même temps. Il garantit un accès exclusif aux ressources partagées.

import (
    "sync"
    "fmt"
)

var (
    mu      sync.Mutex
    counter int
)

func main() {
    for i := 0; i < 1000; i++ {
        go func() {
            mu.Lock()
            counter++
            mu.Unlock()
        }()
    }
    fmt.Println("Final counter value:", counter)
}

Verrouillage en lecture-écriture

Le verrouillage en lecture-écriture (RWMutex) permet à plusieurs goroutines de lire les ressources partagées simultanément, mais une seule goroutine peut écrire des ressources en même temps.

import (
    "sync"
    "fmt"
)

var (
    rwmu  sync.RWMutex
    shared []int
)

func main() {
    // 多个 goroutine 并发读取共享切片
    for i := 0; i < 1000; i++ {
        go func() {
            rwmu.RLock()
            fmt.Println("Read:", shared)
            rwmu.RUnlock()
        }()
    }

    // 单独的 goroutine 写入共享切片
    go func() {
        rwmu.Lock()
        shared = append(shared, 1, 2, 3)
        rwmu.Unlock()
    }()
}

Once

Once est un verrou unique utilisé pour garantir qu'un bloc de code spécifique n'est exécuté qu'une seule fois.

import (
    "sync"
    "fmt"
)

var (
    initOnce sync.Once
    inited   = false
)

func initialize() {
    inited = true
    fmt.Println("Initialized")
}

func main() {
    initOnce.Do(initialize)
    if inited {
        fmt.Println("Already initialized")
    } else {
        fmt.Println("Not initialized")
    }
}

Cas pratique : assurer la cohérence des données dans des services Web simultanés

Supposons qu'il existe un service Web dans lequel plusieurs requêtes simultanées doivent fonctionner sur la même structure de données partagée. Pour garantir la cohérence des données, des verrous mutex peuvent être utilisés pour protéger la structure des données et empêcher les demandes simultanées de la modifier en même temps.

import (
    "sync"
    "net/http"
)

var (
    mu      sync.Mutex
    clients map[string]*http.Client
)

func main() {
    http.HandleFunc("/addClient", func(w http.ResponseWriter, r *http.Request) {
        mu.Lock()
        clients[r.FormValue("name")] = &http.Client{}
        mu.Unlock()
    })
}

Dans cet exemple, l'utilisation d'un mutex mu 保护对 clients l'accès simultané à la carte garantit qu'une seule requête peut ajouter ou modifier les informations client en même temps, évitant ainsi les courses de donné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!