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 (runtime) Go. Contrairement aux threads traditionnels qui consomment une mémoire importante, les goroutines commencent avec seulement quelques kilo-octets d'espace de pile, vous permettant 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 continue immédiatement vers la ligne suivante pendant que sayHello s'exécute en arrière-plan. C'est pourquoi nous avons besoin de time.Sleep — sans cela, main se terminerait avant que les goroutines ne soient terminées.

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

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

La fonction main 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 la possibilité de finir. L'utilisation de time.Sleep est une solution temporaire ; dans les prochaines leçons, vous apprendrez les techniques de synchronisation appropriées avec les canaux et les groupes d'attente.

Défi

Facile

Construisons un exécuteur de tâches qui exécute plusieurs tâches de manière concurrente en utilisant des goroutines. Vous allez créer un système simple où les tâches s'exécutent en arrière-plan pendant que le programme principal continue, démontrant ainsi comment les goroutines permettent l'exécution concurrente.

Vous organiserez votre code sur deux fichiers :

tasks.go : Définissez votre logique d'exécution des 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 s'endormant 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 en tant que goroutine. Après avoir lancé toutes les goroutines, elle doit s'endormir pendant 500 millisecondes pour leur permettre de se terminer, puis afficher : All tasks launched
main.go : Lisez les informations sur les 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 passez-les à RunAllTasks. Une fois qu'elle a terminé, 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 devrait montrer les tâches se terminant (l'ordre peut varier en raison de la concurrence), suivies des messages de fin :

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

Note : Comme les goroutines s'exécutent de manière concurrente, les tâches ayant des durées plus courtes se terminent généralement en premier. L'ordre de fin des tâches dépend de leurs durées - les tâches plus courtes se terminent avant les plus longues.

Utilisez time.Sleep avec time.Duration et time.Millisecond pour les délais. N'oubliez pas que sans le sleep dans RunAllTasks, la fonction se terminerait avant que les goroutines n'aient fini leur travail.

Aide-mémoire

Une goroutine est un thread d'exécution léger géré par le runtime Go. 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 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 simultanément
    go sayHello("Bob")    // s'exécute simultanément
    
    time.Sleep(100 * time.Millisecond)
    fmt.Println("Done")
}

Vous pouvez lancer des goroutines avec des fonctions anonymes :

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

La fonction main elle-même s'exécute dans une goroutine. Lorsqu'elle se termine, toutes les autres goroutines sont immédiatement interrompues. Utilisez time.Sleep pour permettre aux goroutines de se terminer avant que la fonction main ne s'arrête.

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: Afficher "Main function done"
}