Quelles sont les principales constructions utilisées pour gérer et exécuter des goroutines dans le langage de programmation?

Pour gérer et exécuter des goroutines en Go, on utilise les constructions principales suivantes :

• Lancement d'une goroutine : le mot-clé go avant l'appel d'une fonction l'exécute dans une goroutine séparée, par exemple :

  go maFonction()
  

  Cela permet d'exécuter la fonction de manière asynchrone.

• Canaux (channels) : utilisés pour synchroniser et échanger des données entre goroutines. Un canal est créé ainsi :

  ch := make(chan int)
  

  Envoi et réception de données :

  ch <- 42      // envoi
  val := <-ch   // réception
  

  Les canaux assurent une communication sécurisée et bloquent la goroutine si les données ne sont pas prêtes.

• sync.WaitGroup : utilisé pour attendre la fin d'un groupe de goroutines. Exemple :

  var wg sync.WaitGroup
  wg.Add(1)
  go func() {
      defer wg.Done()
      // travail de la goroutine
  }()
  wg.Wait() // attendre la fin de toutes les goroutines
  

• select : permet d'attendre plusieurs opérations sur des canaux simultanément, en choisissant celle prête à s'exécuter. Exemple :

  select {
  case msg := <-ch1:
      fmt.Println("Reçu de ch1 :", msg)
  case ch2 <- 42:
      fmt.Println("Envoyé à ch2")
  default:
      fmt.Println("Aucune opération prête")
  }
  

Ces constructions permettent de lancer, synchroniser et gérer l'exécution parallèle en Go.