Tutoriel de base sur la programmation simultanée Golang : de la prise en main des Goroutines aux applications pratiques

Tutoriel de base sur la programmation simultanée Golang : de la prise en main des Goroutines aux applications pratiques

Introduction :
Avec le développement rapide d'Internet, la demande d'un traitement simultané efficace augmente également. En tant que langage de programmation rapide et efficace, Golang est populaire pour sa puissante prise en charge de la concurrence. Cet article présentera les connaissances de base de la programmation simultanée dans Golang, de la prise en main des Goroutines aux applications pratiques.

1. Qu'est-ce que Goroutine ?
Goroutine est un thread léger dans Golang qui peut s'exécuter simultanément avec d'autres Goroutines. Le coût de création et de destruction des Goroutines est très faible, de sorte que des milliers de Goroutines peuvent être facilement créées pour obtenir un traitement hautement simultané.

Voici un exemple simple montrant comment créer et exécuter un Goroutine :

package main

import (
    "fmt"
    "time"
)

func foo() {
    for i := 0; i < 5; i++ {
        fmt.Println("Goroutine:", i)
        time.Sleep(time.Millisecond * 500)
    }
}

func main() {
    go foo() // 创建并运行一个Goroutine
    for i := 0; i < 5; i++ {
        fmt.Println("Main:", i)
        time.Sleep(time.Millisecond * 500)
    }
}

Dans l'exemple ci-dessus, nous avons créé une fonction nommée foo et l'avons ajoutée dans main() Dans le < /code>, une Goroutine est créée via le mot-clé <code>go pour exécuter simultanément la fonction foo(). Comme vous pouvez le voir, le thread principal et Goroutine s'exécutent en même temps, produisant une sortie toutes les 500 millisecondes. foo的函数，并在main()函数中通过go关键字创建了一个Goroutine来并发执行foo()函数。可以看到，主线程和Goroutine同时运行，每隔500毫秒输出一次。

二、Goroutine之间的通信
Goroutine之间可以通过channel进行通信。channel是一种用于同步和传递数据的类型。可以将其看作是一个队列，Goroutine可以通过channel发送和接收数据。

下面是一个简单的例子，展示如何使用channel进行Goroutine之间的通信：

package main

import (
    "fmt"
)

func send(c chan<- int) {
    for i := 0; i < 5; i++ {
        c <- i // 将数据发送到channel中
    }
    close(c) // 关闭channel
}

func receive(c <-chan int) {
    for num := range c { // 从channel中读取数据，直到channel被关闭
        fmt.Println("Received:", num)
    }
}

func main() {
    c := make(chan int) // 创建一个channel

    go send(c)    // 创建并运行发送Goroutine
    receive(c)    // 接收Goroutine

    fmt.Println("Main exits")
}

在上述例子中，我们创建了一个send函数和一个receive函数。send函数通过channel将0到4的整数发送给receive函数，而receive函数则从channel中读取数据并输出。在主函数中，我们创建了一个channel，并通过Goroutines来并发执行send和receive函数。通过channel进行数据传输和同步。

三、Goroutine的同步与等待
在实际开发中，我们可能需要等待所有的Goroutines完成后再继续执行下一步操作。Golang提供了sync包来实现Goroutines的同步与等待。

下面是一个简单的例子，展示如何使用sync.WaitGroup来等待Goroutines完成：

package main

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

func foo(wg *sync.WaitGroup) {
    defer wg.Done() // 触发WaitGroup计数器减1
    for i := 0; i < 5; i++ {
        fmt.Println("Goroutine:", i)
        time.Sleep(time.Millisecond * 500)
    }
}

func main() {
    var wg sync.WaitGroup

    wg.Add(1)      // 增加WaitGroup计数器
    go foo(&wg)    // 创建并运行一个Goroutine

    wg.Wait()      // 等待所有Goroutines完成

    fmt.Println("Main exits")
}

在上述例子中，我们创建了一个WaitGroup实例，并在main()函数中增加了一个计数器。在foo()函数中，我们使用defer语句来触发计数器减1的操作。通过WaitGroup的Wait()方法来等待Goroutines的完成。这样可以确保所有的Goroutines执行完毕后，再继续执行后续的代码。

结论：
通过本文的介绍，我们了解了Golang中并发编程的基础知识。从Goroutines的创建和运行，到使用channel进行Goroutine之间的通信，再到利用sync.WaitGroup

2. Communication entre les Goroutines

Les Goroutines peuvent communiquer via des canaux. Le canal est un type utilisé pour synchroniser et transmettre des données. Cela peut être considéré comme une file d'attente et Goroutine peut envoyer et recevoir des données via le canal.

🎜Ce qui suit est un exemple simple montrant comment utiliser les canaux de communication entre Goroutines : 🎜rrreee🎜Dans l'exemple ci-dessus, nous avons créé une fonction envoyer et une fonction recevoir. La fonction send envoie des entiers de 0 à 4 à la fonction receive via le canal, et la fonction receive lit les données du canal et les sort . Dans la fonction principale, nous créons un canal et exécutons simultanément les fonctions envoyer et recevoir via Goroutines. La transmission et la synchronisation des données s'effectuent via des canaux. 🎜🎜3. Synchronisation et attente des Goroutines🎜Dans le développement réel, nous devrons peut-être attendre que toutes les Goroutines soient terminées avant de passer à l'étape suivante. Golang fournit le package sync pour implémenter la synchronisation et attendre les Goroutines. 🎜🎜Voici un exemple simple montrant comment utiliser sync.WaitGroup pour attendre la fin des Goroutines : 🎜rrreee🎜Dans l'exemple ci-dessus, nous créons une instance WaitGroup et A counter est ajouté à la fonction main(). Dans la fonction foo(), nous utilisons l'instruction defer pour déclencher l'opération de décrémentation du compteur de 1. Attendez la fin des Goroutines via la méthode Wait() de WaitGroup. Cela garantit que toutes les Goroutines sont exécutées avant de continuer à exécuter le code suivant. 🎜🎜Conclusion : 🎜Grâce à l'introduction de cet article, nous avons appris les bases de la programmation concurrente dans Golang. De la création et de l'exécution des Goroutines à l'utilisation de canaux de communication entre les Goroutines, puis à l'utilisation de sync.WaitGroup pour réaliser la synchronisation et l'attente des Goroutines, nous pouvons mieux appliquer les fonctionnalités de programmation simultanée de Golang pour améliorer les performances du programme et efficacité. 🎜🎜En apprenant et en maîtrisant davantage la programmation simultanée de Golang, je pense que cela sera d'une grande aide dans le développement d'applications Internet à haute concurrence. Continuons à explorer dans la pratique et appliquons-le au développement réel pour créer une meilleure expérience d'application pour les utilisateurs. 🎜

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!