Bases des Goroutines

Fait partie de la section Programmation Orientée Objet du Journey GO de Coddy. Leçon 59 sur 107.

Une goroutine est un fil d’exécution léger géré par l’environnement d’exécution de Go. Contrairement aux fils traditionnels qui consomment beaucoup de mémoire, les goroutines commencent avec seulement quelques kilo-octets d’espace de pile, ce qui vous permet d’en exécuter des milliers simultanément.

Pour démarrer une goroutine, placez simplement le mot-clé go avant un appel de fonction :

func sayHello(name string) {
    fmt.Println("Hello,", name)
}

func main() {
    go sayHello("Alice")  // s'exécute de manière concurrente
    go sayHello("Bob")    // s'exécute de manière concurrente
    
    time.Sleep(100 * time.Millisecond)
    fmt.Println("Done")
}

Lorsque go sayHello("Alice") s’exécute, il n’attend pas que sayHello se termine. Au lieu de cela, il passe immédiatement à la ligne suivante tandis que sayHello s’exécute en arrière-plan. C’est pourquoi nous avons besoin de time.Sleep ; sans lui, main se terminerait avant que les goroutines aient fini.

Vous pouvez également lancer des goroutines avec des fonctions anonymes :

go func(msg string) {
    fmt.Println(msg)
}("Hello from goroutine")

La fonction principale elle-même s’exécute dans une goroutine. Lorsqu’elle se termine, toutes les autres goroutines sont immédiatement interrompues. Elles n’ont pas le temps de terminer. Utiliser time.Sleep est une solution temporaire ; dans les prochaines leçons, tu apprendras des techniques de synchronisation appropriées avec des canaux et des groupes d’attente.

Défi

Facile

Construisons un exécuteur de tâches qui exécute plusieurs tâches simultanément à l'aide de goroutines. Vous allez créer un système simple dans lequel les tâches s'exécutent en arrière-plan tandis que le programme principal continue, afin de montrer comment les goroutines permettent une exécution concurrente.

Vous allez organiser votre code sur deux fichiers :

tasks.go : Définissez la logique d'exécution de vos tâches.
Créez une structure Task avec les champs Name (string) et Duration (int, représentant des millisecondes).

Implémentez une méthode Run() sur Task qui simule un travail en faisant une pause pendant la durée de la tâche, puis affiche : Task [Name] completed

Créez une fonction RunAllTasks(tasks []Task) qui lance la méthode Run() de chaque tâche comme une goroutine. Après avoir lancé toutes les goroutines, elle doit faire une pause de 500 millisecondes pour leur permettre de terminer, puis afficher : All tasks launched
main.go : Lisez les informations des tâches et orchestrez l'exécution concurrente.
Lisez le nombre de tâches, puis lisez le nom et la durée de chaque tâche. Créez les tâches et transmettez-les à RunAllTasks. Après son retour, affichez : Main function done

Les entrées suivantes seront fournies :

Ligne 1 : Nombre de tâches (entier)
Lignes suivantes : Pour chaque tâche, deux lignes : le nom de la tâche, puis sa durée en millisecondes

Par exemple, avec :

3
Download
100
Process
50
Upload
75

Votre sortie doit afficher les tâches terminées (l'ordre peut varier en raison de la concurrence), puis les messages de fin :

Task Process completed
Task Upload completed
Task Download completed
All tasks launched
Main function done

Remarque : puisque les goroutines s'exécutent simultanément, les tâches dont la durée est la plus courte se terminent généralement en premier. L'ordre d'achèvement des tâches dépend de leur durée : les tâches plus courtes se terminent avant les tâches plus longues.

Utilisez time.Sleep avec time.Duration et time.Millisecond pour les délais. N'oubliez pas que sans la pause dans RunAllTasks, la fonction retournerait avant que les goroutines aient terminé leur travail.

Essayez vous-même

package main

import (
	"fmt"
)

func main() {
	// Lire le nombre de tâches
	var numTasks int
	fmt.Scanln(&numTasks)

	// TODO: Créer une slice pour contenir les tâches
	
	// TODO: Lire le nom et la durée de chaque tâche
	// Pour chaque tâche :
	//   - Lire le nom de la tâche
	//   - Lire la durée (en tant qu'entier)
	//   - Créer une Task et l'ajouter à votre slice

	// TODO: Appeler RunAllTasks avec votre slice de tâches

	// TODO: Print "Main function done"
}