Démarrage rapide de la programmation réseau : programmation simultanée en langage Go

Démarrage rapide de la programmation réseau : programmation simultanée en langage Go

Avec le développement d'Internet, la programmation réseau est progressivement devenue l'une des compétences que les programmeurs doivent maîtriser. La programmation simultanée est un élément indispensable de la programmation réseau, en particulier dans les situations de forte concurrence. Le langage Go est un langage de programmation caractérisé par une programmation concurrente efficace, et son modèle de concurrence est plus simple et plus clair que les autres langages. Cet article présentera la programmation simultanée en langage Go pour aider les débutants à démarrer rapidement.

1. Goroutine

Goroutine est un thread léger en langage Go. La concurrence en langage Go est implémentée via Goroutine. Chaque Goroutine peut exécuter différents codes simultanément, et la surcharge de Goroutine est très faible. Des dizaines de milliers de Goroutines peuvent être facilement ouvertes sans se soucier de la consommation de mémoire. L'utilisation de base de Goroutine est très simple. Ajoutez simplement le mot-clé go avant l'appel de fonction pour démarrer un Goroutine.

Par exemple, nous pouvons créer une Goroutine via le code suivant :

func main() {
    go printHello()
}

func printHello() {
    fmt.Println("Hello, world!")
}

Dans le code ci-dessus, lorsque le programme Go s'exécute pour aller printHello(), il démarrera une nouvelle Goroutine pour exécuter la fonction printHello. Étant donné que la fonction printHello s'exécute indépendamment de la fonction principale, le programme affiche immédiatement "Bonjour tout le monde !"

2. Channel

La communication entre les Goroutines se fait via Channel. Le canal peut être considéré comme un pipeline entre les Goroutines et peut être utilisé pour envoyer et recevoir des données. Channel in Go peut transmettre des données de manière synchrone et peut également être utilisé pour mettre en œuvre une programmation asynchrone. La création et l'utilisation de Channel sont également très simples. Utilisez simplement la fonction make pour le créer, puis utilisez l'opérateur <- pour envoyer et recevoir des données.

Par exemple, nous pouvons créer un canal et transmettre des données via le code suivant :

func main() {
    ch := make(chan int)
    go send(ch)
    fmt.Println(<-ch)
}

func send(ch chan int) {
    ch <- 1
}

Dans le code ci-dessus, nous créons un canal entier et démarrons une Goroutine pour la transmission de données. La fonction principale bloque et attend que le canal transmette les données via l'instruction <-ch. Après avoir reçu les données, le programme affichera "1".

Channel peut être utilisé pour transmettre des données entre plusieurs Goroutines, évitant ainsi les problèmes de synchronisation qui doivent être pris en compte lors de l'utilisation de la mémoire partagée. De plus, la coordination et la synchronisation entre plusieurs Goroutines peuvent être réalisées via Channel, réalisant ainsi des tâches de programmation simultanées complexes.

3. Select

Lors de la lecture de données de plusieurs canaux dans plusieurs Goroutines, vous pouvez utiliser la syntaxe de sélection dans le langage Go pour le traitement. La syntaxe de sélection est similaire à la syntaxe Switch. Elle peut surveiller l'interaction des données de plusieurs canaux. Lorsque des données apparaissent dans l'un des canaux, le bloc de code correspondant sera déclenché.

Par exemple, nous pouvons créer deux Goroutines via le code suivant et utiliser la syntaxe select pour traiter la lecture de Chanenl :

func main() {
    ch1 := make(chan int)
    ch2 := make(chan int)
    go func() {
        ch1 <- 1
    }()
    go func() {
        ch2 <- 2
    }()
    select {
        case x := <- ch1:
            fmt.Println("Received from ch1:", x)
        case x := <- ch2:
            fmt.Println("Received from ch2:", x)
    }
}

Dans le code ci-dessus, nous créons deux Goroutines pour envoyer des données à deux canaux respectivement. Utilisez l'instruction select pour surveiller la transmission des données des deux canaux. Tant que l'un des canaux transmet des données, le bloc de code correspondant sera exécuté et les données reçues seront sorties.

4. Mutex

Le langage Go prend en charge plusieurs threads pour accéder simultanément à la même variable Afin de résoudre le problème d'incohérence des données lors de l'écriture d'une variable en même temps, le langage Go fournit un mutex Mutex pour le verrouillage. Lorsque nous modifions la variable, nous ouvrons d'abord le verrou via la méthode Mutex.Lock(). À ce moment, un seul thread a obtenu le verrou, et les autres threads seront bloqués lorsqu'ils tenteront d'obtenir le verrou à ce moment-là ; Après avoir fini d'utiliser la variable, nous devons utiliser manuellement la méthode Mutex.Unlock() pour déverrouiller afin de libérer la ressource de verrouillage.

Par exemple, nous pouvons démontrer l'utilisation de Mutex à travers le code suivant :

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

var wg sync.WaitGroup
var mutex sync.Mutex
var counter int

func main() {
  for i := 0; i < 10; i++ {
    wg.Add(1)
    go increment()
  }
  wg.Wait()
  fmt.Println("Final counter:", counter)
}

func increment() {
  mutex.Lock()
  defer mutex.Unlock()
  counter++
  time.Sleep(time.Second)
  fmt.Println("Counter value:", counter)
  wg.Done()
}

Dans le code ci-dessus, nous créons 10 Goroutines, chaque Goroutine incrémentera la variable compteur de un. Afin de garantir l'exactitude des données, nous utilisons Mutex pour protéger le compteur. Appelez la méthode Mutex.Lock() dans Goroutine pour obtenir le verrou, puis appelez la méthode Mutex.Unlock() pour le déverrouiller après l'opération. Après avoir utilisé WaitGroup pour attendre la fin de toutes les exécutions de Goroutine, affichez la valeur finale du compteur.

Résumé

La programmation simultanée en langage Go utilise Goroutine et Channel pour la transmission de données, la synchronisation et la protection des variables via Mutex, et la lecture de plusieurs canaux via select. En utilisant ces mécanismes de manière rationnelle, nous pouvons écrire des programmes concurrents efficaces, clairs et faciles à maintenir qui jouent un rôle puissant dans les scénarios d’applications à forte concurrence.

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!