Guide de programmation simultanée Golang : Explorer les mystères du traitement parallèle

La programmation simultanée dans Go utilise des threads légers (Goroutine) et des mécanismes de communication (pipelines) pour implémenter l'exécution de tâches parallèles. Les primitives de synchronisation (telles que les mutex) sont utilisées pour coordonner l'accès entre les Goroutines. Des exemples pratiques incluent la création de services Web simultanés efficaces pour gérer plusieurs requêtes.

Guide de la programmation simultanée en Go : explorer les mystères du traitement parallèle

Introduction

La programmation simultanée est un aspect clé du développement logiciel moderne, permettant aux applications d'effectuer plusieurs tâches simultanément, améliorant ainsi l'efficacité et l'évolutivité. Le langage Go le rend idéal pour créer des applications simultanées grâce à son excellente prise en charge de la concurrence.

Bases de Goroutine

Goroutine est un fil de discussion léger dans Go, qui est démarré par le mot-clé go. Ils diffèrent des threads dans la mesure où ils partagent le même espace mémoire mais s'exécutent dans des flux d'exécution différents. go关键字启动。它们与线程不同，因为它们共享相同的内存空间，但运行在不同的执行流中。

在Go中创建一个Goroutine示例代码：

package main

import "fmt"

func main() {
    go func() {
        fmt.Println("Hello from goroutine")
    }()
    fmt.Println("Hello from main")
}

此代码创建一个Goroutine，它并发打印Hello from goroutine，同时主Goroutine打印Hello from main。

通道用于通信

管道是Goroutine之间通信的一种机制。它们类似于缓冲队列，Goroutine可以使用它们发送和接收消息。

创建一个通道的示例代码：

package main

import "fmt"

func main() {
    c := make(chan int)
    go func() { c <- 10 }()
    v := <-c
    fmt.Println(v)
}

此代码创建一个管道c，一个Goroutine向通道发送值10，而主Goroutine从通道接收值并打印。

同步与等待

在并发编程中，同步对于确保Goroutine之间协调执行至关重要。Go提供了各种同步原语，例如互斥体、条件变量和等待组。

使用互斥体保护共享数据示例代码：

package main

import (
    "fmt"
    "sync"
)

func main() {
    var m sync.Mutex
    var count int
    go func() {
        m.Lock()
        count++
        m.Unlock()
    }()
    m.Lock()
    fmt.Println(count)
    m.Unlock()
}

此代码使用互斥体m来确保只有单个Goroutine可以同时访问count

Créer un Goroutine dans Go Exemple de code :

package main

import (
    "fmt"
    "log"
    "net/http"
)

func main() {
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        go func() { fmt.Fprintf(w, "Hello, %s!", r.URL.Path[1:]) }()
    })
    log.Fatal(http.ListenAndServe(":8080", nil))
}

Ce code crée un Goroutine qui imprime simultanément Bonjour de goroutine tandis que le Goroutine principal imprime Bonjour de principal.

Les canaux sont utilisés pour la communication

Les pipelines sont un mécanisme de communication entre les Goroutines. Ils sont similaires aux files d'attente tampon et les Goroutines peuvent les utiliser pour envoyer et recevoir des messages.

Exemple de code pour créer un canal :

rrreee

Ce code crée un tube c, un Goroutine envoie la valeur 10 au canal, et le Goroutine principal reçoit la valeur du canal et l'imprime.

Synchronisation et attente🎜🎜En programmation simultanée, la synchronisation est cruciale pour assurer une exécution coordonnée entre les Goroutines. Go fournit diverses primitives de synchronisation telles que des mutex, des variables de condition et des groupes d'attente. 🎜🎜Utilisez mutex pour protéger l'exemple de code des données partagées : 🎜rrreee🎜Ce code utilise mutex m pour garantir qu'un seul Goroutine peut accéder à la variable count en même temps. 🎜🎜Cas pratique : traitement de la concurrence des services Web🎜🎜Grâce aux fonctionnalités de concurrence de Go, nous pouvons créer des services Web efficaces capables de gérer plusieurs requêtes en même temps. 🎜🎜Cet exemple de code montre un serveur Web simple utilisant Goroutine pour gérer les requêtes entrantes : 🎜rrreee🎜Ce serveur utilise Goroutine pour gérer chaque requête entrante simultanément, améliorant ainsi l'évolutivité et la réactivité. 🎜🎜Conclusion🎜🎜Les capacités de programmation simultanée de Go permettent aux développeurs de créer des applications hautes performances, réactives et évolutives. En maîtrisant les Goroutines, les pipelines, la synchronisation et les groupes d'attente, nous pouvons tirer pleinement parti du traitement parallèle. 🎜

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!