Aller aux bases de Goroutine

Cet article continuera à se concentrer sur la partie de base du langage Go. Nous parlerons un peu des performances et étendrons notre application en créant quelques goroutines simples.

Nous prêterons également attention à certaines des logiques d'exécution sous-jacentes du langage Go et aux différences entre le langage Go et les autres langages.

Concurrence en langage Go

Avant de poursuivre la discussion, nous devons comprendre les concepts de concurrence et de parallélisme. Golang peut réaliser la concurrence et le parallélisme.

Jetons un coup d'œil à la différence entre la concurrence et le parallélisme.

Comprendre la simultanéité

Une application peut gérer plusieurs processus pour accomplir la fonctionnalité prévue. Supposons qu'il s'agisse d'un simple site Web de commerce électronique. Il a été évalué que les tâches suivantes doivent être exécutées simultanément :

1. Afficher la dernière transaction et les informations sur le produit en haut de la page Web ; le nombre actuel d'utilisateurs en ligne du site Web

2. Mettre à jour les détails du panier après que l'utilisateur a sélectionné un article

3. Les besoins du site Web ; pour exécuter toutes ces tâches en même temps pour garder l'utilisateur engagé avec le site Web Restez pertinent et rendez votre site Web attrayant pour les utilisateurs et attirez plus d'affaires.

   Par conséquent, afin de répondre aux besoins de l'entreprise, une simple application ou un site Web peut contenir un ensemble de tâches exécutées en arrière-plan.
4. Dans les deux exemples présentés ci-dessus, plusieurs tâches sont exécutées simultanément, mais il existe encore des différences entre elles. Étudions plus loin pour mieux comprendre.

   Comprendre la concurrence et l'exécution parallèle

Gestion des applications simultanées

Supposons qu'il existe un scénario dans lequel nous avons une machine monocœur qui doit effectuer plusieurs tâches, mais il existe une limitation selon laquelle une seule tâche peut être exécutée sur la machine monocœur à tout moment.

Dans le modèle de concurrence, il existe des changements de contexte entre les tâches. Le programme traite plusieurs tâches, mais comme nous n'avons qu'un seul cœur, les tâches ne peuvent pas être exécutées ensemble.

Le changement de contexte entre les tâches est si rapide que nous avons l'impression que les tâches s'exécutent simultanément.

Il n'y a aucun facteur d'exécution parallèle pendant le processus d'exécution, car il s'agit d'un système monocœur et plusieurs processus ne peuvent pas être exécutés en parallèle.

Comme le montre l'image ci-dessus, la concurrence (sans parallélisme) comporte deux tâches qui doivent être exécutées simultanément. À tout moment, une seule tâche est en cours d'exécution et il existe des changements de contexte entre les tâches.

L'application rejoint le parallélisme

Lors de l'utilisation d'un seul cœur, il y a une limite sur le nombre de cœurs. Si nous ajoutons plus de cœurs à la machine, nous pouvons exécuter des tâches sur différents cœurs simultanément.

Dans l'image ci-dessus (Parallélisme), deux tâches s'exécutent à tout moment, et ces deux tâches s'exécutent sur des cœurs différents.

La concurrence est le traitement simultané de plusieurs tâches sur une certaine période de temps, et le parallélisme est la capacité d'exécuter plusieurs tâches à un moment donné.

En utilisant le langage Go, vous pouvez facilement faire évoluer votre programme d'une exécution simultanée à une exécution parallèle.

Utilisation de Goroutines

Pour utiliser le langage Go afin d'obtenir la concurrence et le parallélisme, nous devons comprendre le concept de Goroutines. La coroutine du langage Go peut être comprise comme un wrapper sur un thread, géré par le runtime Go plutôt que par le système d'exploitation.

Le runtime Go est responsable de l'allocation et du recyclage des ressources aux coroutines. Les coroutines sont très similaires aux threads qui effectuent le multitâche mais consomment moins de ressources que les threads du système d'exploitation. Il n'y a pas de relation un-à-un entre les coroutines et les threads.

Nous pouvons "décomposer" l'application en plusieurs tâches simultanées, qui peuvent être complétées par différentes goroutines. De cette manière, la concurrence linguistique Go peut être obtenue.

Avantages de la coroutine :

1. Plus léger

2. Facile à étendre ;

3. Fils virtuels

4. Nécessite moins de mémoire initiale (2 Ko); un regard sur un exemple simple :

   package main
   
   import (
       "fmt"
       "time"
   )
   
   func main() {
     start := time.Now()
     func() {
       for i:=0; i < 3; i++ {
         fmt.Println(i)
       }
     }()
   
     func() {
       for i:=0; i < 3; i++ {
         fmt.Println(i)
       }
     }()
   
     elapsedTime := time.Since(start)
   
     fmt.Println("Total Time For Execution: " + elapsedTime.String())
   
     time.Sleep(time.Second)
   }

   Copier après la connexion
   Le code ci-dessus exécute successivement deux fonctions indépendantes dans la fonction principale.
5. Le code n'utilise pas de coroutines et le programme est exécuté dans le même thread. Le programme n'a aucune concurrence et les résultats d'exécution sont les suivants :

Le code est exécuté dans l'ordre, en commençant par la fonction principale, en exécutant d'abord la première fonction, puis en exécutant la deuxième fonction, et enfin en sortant normalement de la fonction principale.

Les exemples de scénarios ci-dessus n'utilisent aucune coroutine. Nous pouvons utiliser le mot-clé go pour démarrer la coroutine avant d'exécuter la fonction.

Toujours dans l'exemple ci-dessus, regardons à quoi cela ressemblera après avoir utilisé le mot-clé go pour ouvrir la coroutine :

package main

import (
    "fmt"
    "time"
)

func main() {
  start := time.Now()
  go func() {
    for i:=0; i < 3; i++ {
      fmt.Println(i)
    }
  }()

  go func() {
    for i:=0; i < 3; i++ {
      fmt.Println(i)
    }
  }()

  elapsedTime := time.Since(start)

  fmt.Println("Total Time For Execution: " + elapsedTime.String())

  time.Sleep(time.Second)
}

Le code ci-dessus, utilisez respectivement le mot-clé go Deux coroutines sont ouvertes et leurs fonctions respectives sont exécutées, y compris la coroutine principale. Il y a un total de 3 coroutines.

Dans le code ci-dessus, nous utilisons le mot-clé go pour ouvrir la coroutine. La fonction sera exécutée dans la coroutine au lieu de la coroutine principale. Cela augmente la concurrence et améliore les performances du programme. .

Augmenter le parallélisme

Dans le langage Go, vous pouvez définir le nombre de cœurs pour que le programme s'exécute via la simple ligne de code suivante (PS : à partir de Go 1.5, la valeur par défaut du GOMAXPROCS de Go a été réglé sur le nombre de cœurs du CPU).

runtime.GOMAXPROCS(4)

Cela spécifie que le programme s'exécute sur une machine multicœur. La ligne de code ci-dessus spécifie que le programme peut utiliser quatre cœurs pour s'exécuter.

Une fois qu'une coroutine est créée, elle peut être exécutée dans différents cœurs, permettant un parallélisme et une exécution plus rapide du programme.

package main

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

func main() {
  runtime.GOMAXPROCS(4)
  start := time.Now()
  go func() {
    for i:=0; i < 3; i++ {
      fmt.Println(i)
    }
  }()

  go func() {
    for i:=0; i < 3; i++ {
      fmt.Println(i)
    }
  }()

  elapsedTime := time.Since(start)

  fmt.Println("Total Time For Execution: " + elapsedTime.String())

  time.Sleep(time.Second)
}

Copier après la connexion

Le résultat du code ci-dessus est le suivant :

La concurrence et le parallélisme peuvent être facilement réalisés en utilisant le langage Go. Ajoutez simplement le mot-clé go avant la fonction pour augmenter la vitesse d'exécution du programme.