Une exploration des différences entre la concurrence et le parallélisme dans le langage Go

Explorer les différences entre la concurrence et le parallélisme dans le langage Go

Dans le langage Go, vous entendez souvent les concepts de concurrence et de parallélisme. Bien que ces deux mots soient souvent utilisés de manière interchangeable, ils ont en réalité des significations différentes. Cet article explorera les différences entre la concurrence et le parallélisme dans le langage Go et utilisera des exemples de code spécifiques pour illustrer les différences entre eux.

Tout d'abord, examinons les définitions de la concurrence et du parallélisme :

• La concurrence (concurrence) fait référence au traitement de plusieurs tâches au cours d'une période de temps, ces tâches ne peuvent pas être effectuées en même temps, mais alternativement pour s'améliorer. réactivité et efficacité du système.
• Le parallélisme fait référence au traitement de plusieurs tâches en même temps. Ces tâches s'exécutent réellement sur plusieurs processeurs en même temps pour atteindre des vitesses de traitement plus rapides.

En langage Go, la concurrence est obtenue grâce à la goroutine. Goroutine est un thread léger du langage Go. Il est planifié par le système d'exécution du langage Go et peut réaliser une exécution simultanée sur un seul thread. Une goroutine peut être créée via le mot-clé go, afin que la fonction puisse être exécutée dans une goroutine indépendante. go可以创建一个goroutine，使函数在一个独立的goroutine中执行。

让我们通过一个简单的示例来说明并发和并行的区别：

package main

import (
    "fmt"
    "runtime"
    "time"
)

func task(id int) {
    for i := 0; i < 5; i++ {
        fmt.Printf("Task %d: %d
", id, i)
        time.Sleep(time.Millisecond * 100)
    }
}

func main() {
    runtime.GOMAXPROCS(2) // 设置使用的最大CPU核心数

    go task(1)
    go task(2)

    time.Sleep(time.Second)
}

在上面的代码中，我们定义了两个函数task，每个函数打印5次任务的信息，并在每次打印后暂停100毫秒。在main函数中，我们通过go关键字启动了两个goroutine来执行这两个任务函数。最后，通过time.Sleep函数等待1秒钟，确保两个goroutine足够时间执行完毕。

通过运行以上代码，我们可以看到两个goroutine的任务交替执行，而不是同时执行。这就是并发的概念，尽管任务在同一个线程上交替执行，但在时间上感觉上是并行的，因为它们几乎同时发生。

为了实现并行，我们可以将代码进行一些调整：

package main

import (
    "fmt"
    "runtime"
)

func task(id int) {
    for i := 0; i < 5; i++ {
        fmt.Printf("Task %d: %d
", id, i)
    }
}

func main() {
    runtime.GOMAXPROCS(2) // 设置使用的最大CPU核心数

    go task(1)
    go task(2)

    // 等待任务完成
    fmt.Scanln()
}

在这个修改后的代码中，我们去除了任务函数中的时间暂停，并通过fmt.Scanln()函数让程序等待用户的输入。这样两个goroutine的任务将真正地同时执行，因为它们没有通过时间暂停被阻塞，这就实现了并行的效果。

通过这个示例，我们可以清晰地看到并发和并行的区别。并发是通过在单线程上交替执行多个任务来提高效率，而并行则是真正地同时运行多个任务在多个处理器上。在Go语言中，通过goroutine和GOMAXPROCS

Illustrons la différence entre la concurrence et le parallélisme à travers un exemple simple :

rrreee

Dans le code ci-dessus, nous définissons deux fonctions tâche, chaque fonction imprime les informations de la tâche 5 fois et fait une pause de 100 millisecondes. après chaque impression. Dans la fonction main, nous démarrons deux goroutines via le mot-clé go pour exécuter ces deux fonctions de tâche. Enfin, attendez 1 seconde via la fonction time.Sleep pour vous assurer que les deux goroutines ont suffisamment de temps pour terminer l'exécution.

En exécutant le code ci-dessus, nous pouvons voir que les tâches des deux goroutines sont exécutées alternativement au lieu de simultanément. C'est le concept de concurrence, bien que les tâches soient exécutées alternativement sur le même thread, elles semblent parallèles dans le temps car elles se produisent presque au même moment. 🎜🎜Afin d'obtenir le parallélisme, nous pouvons apporter quelques ajustements au code : 🎜rrreee🎜Dans ce code modifié, nous supprimons la pause temporelle dans la fonction tâche et passons la fonction fmt.Scanln() Laissez le programme attendre la saisie de l'utilisateur. De cette façon, les deux tâches goroutines seront effectivement exécutées en même temps, car elles ne sont pas bloquées par des pauses temporelles, ce qui produit un effet parallèle. 🎜🎜À travers cet exemple, nous pouvons clairement voir la différence entre la concurrence et le parallélisme. La concurrence améliore l'efficacité en exécutant plusieurs tâches alternativement sur un seul thread, tandis que le parallélisme exécute véritablement plusieurs tâches sur plusieurs processeurs en même temps. Dans le langage Go, la concurrence et le parallélisme peuvent être facilement obtenus grâce à goroutine et à la fonction GOMAXPROCS. 🎜🎜De manière générale, maîtriser les concepts de concurrence et de parallélisme est crucial pour comprendre l'application de la programmation concurrente dans le langage Go. Ce n'est qu'en comprenant profondément la différence entre les deux que nous pourrons mieux utiliser les fonctionnalités du langage Go pour écrire des programmes concurrents efficaces. 🎜🎜Grâce à l'exploration de cet article, j'espère que les lecteurs auront une compréhension plus claire des concepts de concurrence et de parallélisme dans le langage Go, et pourront également approfondir leur compréhension de ces deux concepts à travers des exemples de code spécifiques. Dans la programmation actuelle en langage Go, l'utilisation flexible de la concurrence et de la technologie parallèle contribuera à améliorer les performances et l'efficacité du programme. 🎜

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!