GO : concurrence vs parallélisme pour les nuls.

Bienvenue sur ce post au titre quelque peu dégradant.
Mais, dans cet article, je veux vous expliquer ce que sont ces 2 caractéristiques de la programmation d'une manière très simple, cette fois en utilisant mon langage de programmation préféré GOLANG.

Imaginons une cuisine :

Cuisiner un plat : Cela représente une tâche.
Un cuisinier : Il est transformateur.
Participation :

Plusieurs cuisiniers en cuisine : Chacun préparant un plat différent.
In Go : Chaque cuisinier serait un goroutine. Bien que la cuisine (processeur) ne dispose que d'un seul four, les cuisiniers peuvent travailler simultanément sur leurs plats, passant du temps sur d'autres tâches en attendant que le four soit disponible.
Parallélisme :

Divers fours : Chaque cuisinier possède son propre four.
In Go : Si nous avons plusieurs processeurs physiques, chaque goroutine pourrait fonctionner sur un processeur différent, cuisinant plusieurs plats en même temps de manière réelle.

Quelle est la différence ?

Concurrency : Les tâches sont exécutées entrelacées, donnant l'illusion de parallélisme, même sur un seul processeur.
Parallélisme : les tâches s'exécutent simultanément sur plusieurs processeurs, ce qui accélère considérablement le processus.

Comment les utiliser dans Go ?

Goroutines : Elles sont comme des fils légers. Pour créer une goroutine, on utilise simplement le mot clé go avant une fonction :

Voyons un exemple de la façon dont nous pouvons utiliser les goroutines en golang :

go func() {
    // Código que se ejecutará en una goroutine
}()

Canaux : Ce sont des canaux à travers lesquels les goroutines peuvent communiquer et se synchroniser.
Imaginez que ce soient des tubes pour faire passer les ingrédients entre les cuisiniers

ch := make(chan int)
go func() {
    ch <- 42 // Enviar un valor por el canal
}()
value := <-ch // Recibir un valor del canal

Exemple pratique :

package main

import (
    "fmt"
    "time"
)

func worker(id int, c chan int) {
    for n := range c {
        fmt.Printf("Worker %d received %d\n", id, n)
        time.Sleep(time.Second)
    }
}

func main() {
    c := make(chan int)

    for i := 1; i <= 5; i++ {
        go worker(i, c)
    }

    for n := 1; n <= 10; n++ {
        c <- n
    }
    close(c)

    time.Sleep(time.Second)
}

La sortie de ce code serait

Worker 1 received 1
Worker 2 received 2
Worker 3 received 3
Worker 4 received 4
Worker 5 received 5
Worker 1 received 6
Worker 2 received 7
Worker 3 received 8
Worker 4 received 9
Worker 5 received 10

même si parfois cela pourrait ressembler à ceci

Worker 5 received 1
Worker 1 received 3
Worker 2 received 2
Worker 4 received 5
Worker 3 received 4
Worker 3 received 6
Worker 5 received 10
Worker 2 received 8
Worker 4 received 7
Worker 1 received 9

ou comme ça

Worker 5 received 1
Worker 1 received 2
Worker 2 received 3
Worker 3 received 4
Worker 4 received 5
Worker 1 received 6
Worker 2 received 7
Worker 3 received 8
Worker 5 received 9
Worker 4 received 10

Pourquoi le résultat change-t-il à chaque fois que j'exécute le programme ?

La principale raison pour laquelle le résultat du programme change à chaque exécution est due à la nature non déterministe de la concurrence.

Voici un aperçu de ce qui se passe :

Créer un canal : make(chan int) crée un canal d'entiers. Ce canal sera utilisé pour la communication entre les goroutines.

Démarrer les goroutines : La boucle pour i := 1; je La fonction de travail reçoit l'ID et le canal.

Envoyer les valeurs au canal : La boucle pour n := 1 ; n 1 à 10 au canal.

Fermer le canal : L'appel close(c) ferme le canal, indiquant qu'aucune autre valeur ne sera envoyée.

Recevoir les valeurs du canal : Chaque goroutine reçoit les valeurs du canal en utilisant la boucle for n := range c. Lorsqu'une valeur est reçue, elle est imprimée sur la console.

Attendez la fin des goroutines : L'appel time.Sleep(time.Second) garantit que la goroutine principale attend la fin des autres goroutines avant de quitter.

Jusqu'à présent :

Nous créons 5 goroutines (cuisiniers) qui reçoivent des numéros via un canal.
Nous envoyons des numéros au canal pour que les cuisiniers les traitent.
Les cuisiniers travaillent simultanément, traitant les numéros au fur et à mesure qu'ils les reçoivent.

Pourquoi utiliser la concurrence et le parallélisme dans Go ?

Meilleures performances : en particulier dans les tâches liées aux E/S (telles que la lecture de fichiers ou l'envoi de requêtes HTTP).
Réactivité accrue : L'application peut continuer à répondre à d'autres requêtes pendant qu'une tâche est verrouillée.
Archites plus évolutives : vous pouvez répartir le travail sur plusieurs cœurs ou machines.

Souvenez-vous !

La concurrence et le parallélisme sont des outils puissants, mais ils peuvent également rendre le code plus complexe à comprendre et à déboguer. Il est important de les utiliser avec précaution et de comprendre leurs implications.

Voulez-vous approfondir un sujet spécifique ?

Nous pouvons explorer des concepts tels que :

Synchronisation : Mutex, groupes de travail, etc.
Modèles de concurrence : producteur-consommateur, pipeline, etc.
Tests simultanés : comment tester efficacement le code simultané.

Salutations,
Lucatonny Raudales

X/Twitter
Github

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!