Maîtriser le modèle de concurrence et le mécanisme de verrouillage en langage Go

Maîtrisez le modèle de concurrence et le mécanisme de verrouillage en langage Go

Avec le développement rapide d'Internet et les besoins croissants des utilisateurs, la demande de langages de programmation hautes performances et à haute concurrence est également de plus en plus élevée. En tant que langage de programmation open source, le langage Go est devenu le langage de premier choix pour créer des programmes à haute concurrence grâce à son modèle de concurrence efficace et à son mécanisme de verrouillage flexible.

1. Modèle de concurrence

Le langage Go utilise le mécanisme de thread léger Goroutine pour obtenir la concurrence. Goroutine est un thread très léger qui est programmé en bas par le runtime du langage Go. Il peut être créé par le mot-clé Go ou démarré par le mot-clé go. Par rapport au modèle de thread traditionnel, Goroutine ne nécessite pas de gestion explicite des threads, mais est automatiquement géré par le runtime. Le planificateur de Goroutine utilise une stratégie de planification préemptive, c'est-à-dire que chaque fragment de programme sera réparti aussi uniformément que possible entre les différents Goroutines, permettant ainsi une exécution simultanée.

2. Programmation simultanée

Dans le langage Go, la manière la plus simple d'utiliser la programmation simultanée est de démarrer une nouvelle Goroutine en utilisant le mot-clé go. Voici un exemple de code simple :

package main

import (
    "fmt"
    "time"
)

func main() {
    go printCount("Hello", 5)
    go printCount("World", 5)
    
    time.Sleep(time.Second * 2)
}

func printCount(word string, count int) {
    for i := 0; i < count; i++ {
        fmt.Println(word)
        time.Sleep(time.Millisecond * 500)
    }
}

Dans le code ci-dessus, nous utilisons deux goroutines pour imprimer respectivement "Hello" et "World". Chaque goroutine s'imprime 5 fois, et les deux goroutines s'exécutent en même temps. En ajoutant time.Sleep, laissez la goroutine principale attendre un certain temps pour vous assurer que les deux goroutines ont suffisamment de temps pour s'exécuter.

3. Mécanisme de verrouillage

En programmation simultanée, afin d'assurer la synchronisation des données entre plusieurs goroutines, nous devons généralement utiliser un mécanisme de verrouillage. Le langage Go fournit le package de synchronisation pour prendre en charge divers mécanismes de verrouillage, notamment le mutex (Mutex), le verrouillage en lecture-écriture (RWMutex), etc.

Le verrouillage Mutex est le mécanisme de verrouillage le plus simple, qui implémente le contrôle d'accès aux ressources partagées via les méthodes Lock() et Unlock(). Voici un exemple de code pour un verrou mutex :

package main

import (
    "fmt"
    "sync"
    "time"
)

var count int
var mutex sync.Mutex

func main() {
    for i := 0; i < 100; i++ {
        go increment()
    }
    
    time.Sleep(time.Second)
    fmt.Println("Count:", count)
}

func increment() {
    mutex.Lock()
    defer mutex.Unlock()
    count++
}

Dans le code ci-dessus, nous définissons un nombre de variables globales, puis utilisons le mutex de verrouillage mutex pour protéger les accès simultanés au nombre. Dans la fonction d'incrémentation, nous utilisons la méthode Lock() pour acquérir le verrou, en garantissant qu'une seule goroutine peut exécuter la fonction à la fois, puis utilisons la méthode Unlock() pour libérer le verrou. Grâce à l'utilisation de verrous mutex, nous pouvons garantir que le fonctionnement du comptage est sûr et que la valeur de sortie finale du comptage est également correcte.

En plus des verrous mutex, le langage Go fournit également d'autres mécanismes de verrouillage tels que les verrous en lecture-écriture (RWMutex) pour contrôler de manière plus flexible l'accès des différentes goroutines aux ressources partagées.

Pour résumer, le modèle de concurrence et le mécanisme de verrouillage du langage Go nous offrent un moyen efficace et sûr de gérer la programmation simultanée. La maîtrise de ces fonctionnalités peut nous aider à mieux créer des programmes hautement concurrents et à améliorer les performances et la fiabilité des programmes.

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!