Concepts et techniques de programmation concurrente en langage Go

Avec le développement continu de la technologie informatique, les processeurs multicœurs sont devenus la norme. La programmation simultanée est extrêmement importante dans le développement logiciel actuel, et le langage Go est devenu l'un des langages de programmation simultanée les plus populaires en raison de son mécanisme de concurrence unique. Dans cet article, nous aborderons les concepts et techniques de programmation concurrente en langage Go.

1. Le concept de concurrence

La concurrence signifie que deux événements ou plus se produisent dans le même intervalle de temps. En informatique, cela signifie que plusieurs tâches peuvent être exécutées simultanément dans le même intervalle de temps. La programmation simultanée fait référence à la technologie de programmation consistant à écrire des programmes capables d'effectuer plusieurs tâches en même temps.

Les concepts de programmation concurrente et de programmation parallèle sont différents. La programmation simultanée fait référence à l'exécution de plusieurs tâches simultanément, tandis que la programmation parallèle fait référence à l'exécution de plusieurs tâches simultanément sur plusieurs processeurs ou cœurs de traitement. Dans le domaine informatique, la concurrence et le parallélisme sont souvent utilisés de manière interchangeable, mais ils sont essentiellement différents.

2. Concurrence dans le langage Go

Le langage Go prend en charge la programmation simultanée dans la syntaxe et dans l'exécution. Goroutine en langage Go est un thread extrêmement léger. Un Goroutine n'a besoin que d'occuper une petite quantité d'espace de pile pour s'exécuter. En même temps, un programme Go peut avoir des milliers de Goroutines, ce qui permet à un programme Go d'exécuter efficacement des tâches simultanées.

La concurrence dans le langage Go adopte le modèle de concurrence CSP, qui partage la mémoire via la communication au lieu de communiquer via la mémoire partagée. Dans le langage Go, nous pouvons utiliser des canaux pour mettre en œuvre la communication entre Goroutines.

Vous pouvez définir un canal de la manière suivante :

ch := make(chan int)

Utilisez le mot-clé go intégré du langage Go pour démarrer une Goroutine : go 关键字来启动一个 Goroutine：

go printHelloWorld()

在这段代码中，printHelloWorld() 是一个函数，通过 go 关键字启动的这个 Goroutine 会在一个新的线程独立运行。

3. 并发编程的技巧

3.1 使用 channel 来协调 Goroutine

如上所述，在Go语言中，我们可以使用 channel 来实现 Goroutine 之间的通信。channel 可以用于两个或多个 Goroutine 之间的协调，以及对共享资源的控制。

package main

import "fmt"

func hello(done chan bool) {
    fmt.Println("Hello world Goroutine")
    done <- true
}

func main() {
    done := make(chan bool)
    go hello(done)
    <-done
    fmt.Println("main function")
}

在这段代码中，我们在 hello() 函数外部定义了一个 done channel，并将其传递给 hello() 函数。在 hello() 函数中，我们打印了一条消息，并将 true 值写入了 done channel 中，表示 hello() 函数执行完毕。在 main() 函数中，我们通过 <-done 语法从 channel 中读取数据，等待 hello() 函数执行完毕并将 true 值写入 done channel 中。这样，我们就实现了 Goroutine 的协调。

3.2 使用 select 语句

select 语句可以用于同时处理多个 channel 操作。在 select 语句中，我们可以定义多个 channel，然后通过一组 case 语句来处理它们。

package main

import (
    "fmt"
    "time"
)

func main() {
    ch1 := make(chan int)
    ch2 := make(chan string)

    go func() {
        ch1 <- 1
    }()

    go func() {
        ch2 <- "hello"
    }()

    for i := 0; i < 2; i++ {
        select {
        case num := <-ch1:
            fmt.Println("ch1:", num)
        case str := <-ch2:
            fmt.Println("ch2:", str)
        case <-time.After(time.Millisecond * 100):
            fmt.Println("timeout")
        }
    }
}

在这段代码中，我们定义了 ch1 和 ch2 两个 channel，并启动了两个 Goroutine，分别向这两个 channel 中写入数据。在 main() 函数中，我们通过一个 for 循环来处理这两个 channel 的输入，使用 select 语句来选择其中一个可用的 channel 并处理其输入。如果在一个固定时间内没有 channel 可以使用，我们可以使用 time.After()rrreee

3. Conseils de programmation simultanée

3.1 Utiliser des canaux pour coordonner les Goroutines

🎜Comme mentionné ci-dessus, en langage Go, nous pouvons utiliser des canaux pour mettre en œuvre la communication entre les Goroutines. Les canaux peuvent être utilisés pour la coordination entre deux ou plusieurs Goroutines et pour le contrôle des ressources partagées. 🎜rrreee🎜Dans ce code, nous définissons un canal done en dehors de la fonction hello() et le passons à la fonction hello(). Dans la fonction hello(), nous imprimons un message et écrivons la valeur true dans le canal done, représentant hello () L'exécution de la fonction est terminée. Dans la fonction <code>main(), nous lisons les données du canal via la syntaxe <-done, attendons que la fonction hello() complete et écrit la valeur true dans le canal done. De cette façon, nous obtenons la coordination Goroutine. 🎜🎜3.2 Utiliser l'instruction select🎜🎜L'instruction select peut être utilisée pour traiter plusieurs opérations de canal en même temps. Dans l'instruction select, nous pouvons définir plusieurs canaux, puis les traiter via un ensemble d'instructions case. 🎜rrreee🎜Dans ce code, nous avons défini deux canaux, ch1 et ch2, et avons démarré deux Goroutines pour écrire des données sur ces deux canaux respectivement. Dans la fonction main(), nous traitons l'entrée de ces deux canaux via une boucle for et utilisons l'instruction select pour sélectionner l'un des canaux disponibles et traiter son entrée. Si aucun canal n'est disponible dans un délai déterminé, nous pouvons utiliser la fonction time.After() pour implémenter le traitement du délai d'attente. 🎜🎜🎜Conclusion🎜🎜🎜Dans cet article, nous avons abordé les concepts et techniques de programmation concurrente en langage Go. Grâce à Goroutine et Channel, nous pouvons mettre en œuvre efficacement la programmation simultanée. Lors de l'écriture de programmes simultanés, nous devons suivre certaines techniques de base, telles que l'utilisation de canaux pour coordonner les Goroutines et l'utilisation d'instructions select pour synchroniser l'exécution de plusieurs Goroutines. Ces techniques peuvent nous aider à écrire des programmes concurrents efficaces et stables. 🎜

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!